utils.c 93.3 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * Various utilities for ffmpeg system
Fabrice Bellard's avatar
Fabrice Bellard committed
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
Fabrice Bellard's avatar
Fabrice Bellard committed
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Fabrice Bellard's avatar
Fabrice Bellard committed
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
16
 *
Fabrice Bellard's avatar
Fabrice Bellard committed
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
20
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
21
#include "avformat.h"
22
#include "allformats.h"
23
#include "opt.h"
24

25 26 27
#undef NDEBUG
#include <assert.h>

28 29 30 31 32
/**
 * @file libavformat/utils.c
 * Various utility functions for using ffmpeg library.
 */

33 34 35 36
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
static void av_frac_add(AVFrac *f, int64_t incr);
static void av_frac_set(AVFrac *f, int64_t val);

37
/** head of registered input format linked list. */
38
AVInputFormat *first_iformat = NULL;
39
/** head of registered output format linked list. */
40
AVOutputFormat *first_oformat = NULL;
41
/** head of registered image format linked list. */
42
AVImageFormat *first_image_format = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
43

44
void av_register_input_format(AVInputFormat *format)
Fabrice Bellard's avatar
Fabrice Bellard committed
45
{
46 47 48 49 50 51 52 53 54 55 56
    AVInputFormat **p;
    p = &first_iformat;
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

void av_register_output_format(AVOutputFormat *format)
{
    AVOutputFormat **p;
    p = &first_oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
57 58 59 60 61
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

62
int match_ext(const char *filename, const char *extensions)
Fabrice Bellard's avatar
Fabrice Bellard committed
63 64 65 66
{
    const char *ext, *p;
    char ext1[32], *q;

Michael Niedermayer's avatar
Michael Niedermayer committed
67 68
    if(!filename)
        return 0;
69

Fabrice Bellard's avatar
Fabrice Bellard committed
70 71 72 73 74 75
    ext = strrchr(filename, '.');
    if (ext) {
        ext++;
        p = extensions;
        for(;;) {
            q = ext1;
76
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
Fabrice Bellard's avatar
Fabrice Bellard committed
77 78
                *q++ = *p++;
            *q = '\0';
79
            if (!strcasecmp(ext1, ext))
Fabrice Bellard's avatar
Fabrice Bellard committed
80
                return 1;
81
            if (*p == '\0')
Fabrice Bellard's avatar
Fabrice Bellard committed
82 83 84 85 86 87 88
                break;
            p++;
        }
    }
    return 0;
}

89
AVOutputFormat *guess_format(const char *short_name, const char *filename,
90
                             const char *mime_type)
Fabrice Bellard's avatar
Fabrice Bellard committed
91
{
92
    AVOutputFormat *fmt, *fmt_found;
Fabrice Bellard's avatar
Fabrice Bellard committed
93 94
    int score_max, score;

Fabrice Bellard's avatar
Fabrice Bellard committed
95
    /* specific test for image sequences */
96
#ifdef CONFIG_IMAGE2_MUXER
97
    if (!short_name && filename &&
98
        av_filename_number_test(filename) &&
99 100 101
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
        return guess_format("image2", NULL, NULL);
    }
102
#endif
103
    if (!short_name && filename &&
104
        av_filename_number_test(filename) &&
105
        guess_image_format(filename)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
106 107 108
        return guess_format("image", NULL, NULL);
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
109 110 111
    /* find the proper file type */
    fmt_found = NULL;
    score_max = 0;
112
    fmt = first_oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
113 114 115 116 117 118
    while (fmt != NULL) {
        score = 0;
        if (fmt->name && short_name && !strcmp(fmt->name, short_name))
            score += 100;
        if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
            score += 10;
119
        if (filename && fmt->extensions &&
Fabrice Bellard's avatar
Fabrice Bellard committed
120 121 122 123 124 125 126 127 128 129
            match_ext(filename, fmt->extensions)) {
            score += 5;
        }
        if (score > score_max) {
            score_max = score;
            fmt_found = fmt;
        }
        fmt = fmt->next;
    }
    return fmt_found;
130
}
Fabrice Bellard's avatar
Fabrice Bellard committed
131

132
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
                             const char *mime_type)
{
    AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);

    if (fmt) {
        AVOutputFormat *stream_fmt;
        char stream_format_name[64];

        snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
        stream_fmt = guess_format(stream_format_name, NULL, NULL);

        if (stream_fmt)
            fmt = stream_fmt;
    }

    return fmt;
}

151
/**
152
 * Guesses the codec id based upon muxer and filename.
153
 */
154
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
155 156 157 158
                            const char *filename, const char *mime_type, enum CodecType type){
    if(type == CODEC_TYPE_VIDEO){
        enum CodecID codec_id= CODEC_ID_NONE;

159
#ifdef CONFIG_IMAGE2_MUXER
160
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
161 162
            codec_id= av_guess_image2_codec(filename);
        }
163
#endif
164 165 166 167 168 169 170 171 172
        if(codec_id == CODEC_ID_NONE)
            codec_id= fmt->video_codec;
        return codec_id;
    }else if(type == CODEC_TYPE_AUDIO)
        return fmt->audio_codec;
    else
        return CODEC_ID_NONE;
}

173 174 175
/**
 * finds AVInputFormat based on input format's short name.
 */
176 177 178 179 180 181 182 183 184 185
AVInputFormat *av_find_input_format(const char *short_name)
{
    AVInputFormat *fmt;
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
        if (!strcmp(fmt->name, short_name))
            return fmt;
    }
    return NULL;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
186 187
/* memory handling */

188
/**
189
 * Default packet destructor.
190
 */
191
void av_destruct_packet(AVPacket *pkt)
192 193 194 195 196
{
    av_free(pkt->data);
    pkt->data = NULL; pkt->size = 0;
}

197 198 199 200 201 202 203
/**
 * Allocate the payload of a packet and intialized its fields to default values.
 *
 * @param pkt packet
 * @param size wanted payload size
 * @return 0 if OK. AVERROR_xxx otherwise.
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
204 205
int av_new_packet(AVPacket *pkt, int size)
{
206
    uint8_t *data;
207
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
208
        return AVERROR_NOMEM;
209
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
210
    if (!data)
211
        return AVERROR_NOMEM;
212
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
213

214
    av_init_packet(pkt);
215
    pkt->data = data;
216 217
    pkt->size = size;
    pkt->destruct = av_destruct_packet;
Fabrice Bellard's avatar
Fabrice Bellard committed
218 219 220
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
/**
 * Allocate and read the payload of a packet and intialized its fields to default values.
 *
 * @param pkt packet
 * @param size wanted payload size
 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
 */
int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
{
    int ret= av_new_packet(pkt, size);

    if(ret<0)
        return ret;

    pkt->pos= url_ftell(s);

    ret= get_buffer(s, pkt->data, size);
    if(ret<=0)
        av_free_packet(pkt);
    else
        pkt->size= ret;

    return ret;
}

246 247 248 249 250 251
/* This is a hack - the packet memory allocation stuff is broken. The
   packet is allocated if it was not really allocated */
int av_dup_packet(AVPacket *pkt)
{
    if (pkt->destruct != av_destruct_packet) {
        uint8_t *data;
252 253
        /* we duplicate the packet and don't forget to put the padding
           again */
254
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
255
            return AVERROR_NOMEM;
256
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
257 258 259 260
        if (!data) {
            return AVERROR_NOMEM;
        }
        memcpy(data, pkt->data, pkt->size);
261
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
262 263 264 265 266 267
        pkt->data = data;
        pkt->destruct = av_destruct_packet;
    }
    return 0;
}

268 269 270 271 272 273 274
/**
 * Allocate the payload of a packet and intialized its fields to default values.
 *
 * @param filename possible numbered sequence string
 * @return 1 if a valid numbered sequence string, 0 otherwise.
 */
int av_filename_number_test(const char *filename)
275 276
{
    char buf[1024];
277
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
278 279
}

280 281 282
/**
 * Guess file format.
 */
283
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
284 285 286 287 288 289 290 291 292 293
{
    AVInputFormat *fmt1, *fmt;
    int score, score_max;

    fmt = NULL;
    score_max = 0;
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
        if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
            continue;
        score = 0;
294 295 296
        if (fmt1->read_probe) {
            score = fmt1->read_probe(pd);
        } else if (fmt1->extensions) {
297 298 299
            if (match_ext(pd->filename, fmt1->extensions)) {
                score = 50;
            }
300
        }
301 302 303 304 305 306 307 308 309 310
        if (score > score_max) {
            score_max = score;
            fmt = fmt1;
        }
    }
    return fmt;
}

/************************************************************/
/* input media file */
311

312
/**
313
 * Open a media file from an IO stream. 'fmt' must be specified.
314
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
315
static const char* format_to_name(void* ptr)
316
{
Michael Niedermayer's avatar
Michael Niedermayer committed
317
    AVFormatContext* fc = (AVFormatContext*) ptr;
318 319 320 321 322
    if(fc->iformat) return fc->iformat->name;
    else if(fc->oformat) return fc->oformat->name;
    else return "NULL";
}

323
#define OFFSET(x) offsetof(AVFormatContext,x)
324 325 326 327 328 329
#define DEFAULT 0 //should be NAN but it doesnt work as its not a constant in glibc as required by ANSI/ISO C
//these names are too long to be readable
#define E AV_OPT_FLAG_ENCODING_PARAM
#define D AV_OPT_FLAG_DECODING_PARAM

static const AVOption options[]={
330
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
331
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
332
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
333
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
334 335
{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
336
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
337
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
338 339 340
{NULL},
};

341 342 343 344
#undef E
#undef D
#undef DEFAULT

345 346
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };

Michael Niedermayer's avatar
Michael Niedermayer committed
347
#if LIBAVFORMAT_VERSION_INT >= ((51<<16)+(0<<8)+0)
348 349
static
#endif
350 351
void avformat_get_context_defaults(AVFormatContext *s){
    memset(s, 0, sizeof(AVFormatContext));
352

353 354 355
    s->av_class = &av_format_context_class;

    av_opt_set_defaults(s);
356
}
357 358 359 360

AVFormatContext *av_alloc_format_context(void)
{
    AVFormatContext *ic;
361
    ic = av_malloc(sizeof(AVFormatContext));
362
    if (!ic) return ic;
363
    avformat_get_context_defaults(ic);
Michael Niedermayer's avatar
Michael Niedermayer committed
364
    ic->av_class = &av_format_context_class;
365 366 367
    return ic;
}

368 369 370 371
/**
 * Allocates all the structures needed to read an input stream.
 *        This does not open the needed codecs for decoding the stream[s].
 */
372 373
int av_open_input_stream(AVFormatContext **ic_ptr,
                         ByteIOContext *pb, const char *filename,
374 375 376 377
                         AVInputFormat *fmt, AVFormatParameters *ap)
{
    int err;
    AVFormatContext *ic;
378 379 380 381 382 383
    AVFormatParameters default_ap;

    if(!ap){
        ap=&default_ap;
        memset(ap, 0, sizeof(default_ap));
    }
384

385 386 387 388
    if(!ap->prealloced_context)
        ic = av_alloc_format_context();
    else
        ic = *ic_ptr;
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
    if (!ic) {
        err = AVERROR_NOMEM;
        goto fail;
    }
    ic->iformat = fmt;
    if (pb)
        ic->pb = *pb;
    ic->duration = AV_NOPTS_VALUE;
    ic->start_time = AV_NOPTS_VALUE;
    pstrcpy(ic->filename, sizeof(ic->filename), filename);

    /* allocate private data */
    if (fmt->priv_data_size > 0) {
        ic->priv_data = av_mallocz(fmt->priv_data_size);
        if (!ic->priv_data) {
            err = AVERROR_NOMEM;
            goto fail;
        }
    } else {
        ic->priv_data = NULL;
    }

    err = ic->iformat->read_header(ic, ap);
    if (err < 0)
        goto fail;
414 415 416 417

    if (pb)
        ic->data_offset = url_ftell(&ic->pb);

418 419 420 421 422 423 424 425 426 427 428
    *ic_ptr = ic;
    return 0;
 fail:
    if (ic) {
        av_freep(&ic->priv_data);
    }
    av_free(ic);
    *ic_ptr = NULL;
    return err;
}

429
/** Size of probe buffer, for guessing file type from file contents. */
430
#define PROBE_BUF_MIN 2048
431
#define PROBE_BUF_MAX (1<<20)
432 433 434 435 436 437 438 439 440 441 442 443

/**
 * Open a media file as input. The codec are not opened. Only the file
 * header (if present) is read.
 *
 * @param ic_ptr the opened media file handle is put here
 * @param filename filename to open.
 * @param fmt if non NULL, force the file format to use
 * @param buf_size optional buffer size (zero if default is OK)
 * @param ap additionnal parameters needed when opening the file (NULL if default)
 * @return 0 if OK. AVERROR_xxx otherwise.
 */
444
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
445 446 447
                       AVInputFormat *fmt,
                       int buf_size,
                       AVFormatParameters *ap)
Fabrice Bellard's avatar
Fabrice Bellard committed
448
{
449
    int err, must_open_file, file_opened, probe_size;
450
    AVProbeData probe_data, *pd = &probe_data;
451
    ByteIOContext pb1, *pb = &pb1;
452

453 454 455 456
    file_opened = 0;
    pd->filename = "";
    if (filename)
        pd->filename = filename;
457
    pd->buf = NULL;
458 459 460 461
    pd->buf_size = 0;

    if (!fmt) {
        /* guess format if no file can be opened  */
462
        fmt = av_probe_input_format(pd, 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
463 464
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
465 466 467
    /* do not open file if the format does not need it. XXX: specific
       hack needed to handle RTSP/TCP */
    must_open_file = 1;
468
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
469
        must_open_file = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
470
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
Fabrice Bellard's avatar
Fabrice Bellard committed
471 472 473
    }

    if (!fmt || must_open_file) {
Fabrice Bellard's avatar
Fabrice Bellard committed
474
        /* if no file needed do not try to open one */
475
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
476
            err = AVERROR_IO;
477
            goto fail;
478
        }
479
        file_opened = 1;
480
        if (buf_size > 0) {
481
            url_setbufsize(pb, buf_size);
482
        }
483 484

        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
485
            /* read probe data */
486 487
            pd->buf= av_realloc(pd->buf, probe_size);
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
488 489 490
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
                url_fclose(pb);
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
491
                    file_opened = 0;
492 493 494 495
                    err = AVERROR_IO;
                    goto fail;
                }
            }
496 497
            /* guess file format */
            fmt = av_probe_input_format(pd, 1);
498
        }
499
        av_freep(&pd->buf);
500 501 502 503 504
    }

    /* if still no format found, error */
    if (!fmt) {
        err = AVERROR_NOFMT;
505
        goto fail;
Fabrice Bellard's avatar
Fabrice Bellard committed
506
    }
507

508
    /* XXX: suppress this hack for redirectors */
509
#ifdef CONFIG_NETWORK
510
    if (fmt == &redir_demuxer) {
511 512
        err = redir_open(ic_ptr, pb);
        url_fclose(pb);
513 514
        return err;
    }
515
#endif
516

Fabrice Bellard's avatar
Fabrice Bellard committed
517
    /* check filename in case of an image number is expected */
518
    if (fmt->flags & AVFMT_NEEDNUMBER) {
519
        if (!av_filename_number_test(filename)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
520
            err = AVERROR_NUMEXPECTED;
521
            goto fail;
Fabrice Bellard's avatar
Fabrice Bellard committed
522 523
        }
    }
524 525 526
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
    if (err)
        goto fail;
527
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
528
 fail:
529
    av_freep(&pd->buf);
530 531
    if (file_opened)
        url_fclose(pb);
532 533
    *ic_ptr = NULL;
    return err;
534

Fabrice Bellard's avatar
Fabrice Bellard committed
535 536
}

537 538
/*******************************************************/

539
/**
540 541 542 543
 * Read a transport packet from a media file.
 *
 * This function is absolete and should never be used.
 * Use av_read_frame() instead.
544
 *
545
 * @param s media file handle
546 547
 * @param pkt is filled
 * @return 0 if OK. AVERROR_xxx if error.
548
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
549
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
550 551 552 553 554 555
{
    return s->iformat->read_packet(s, pkt);
}

/**********************************************************/

556 557 558
/**
 * Get the number of samples of an audio frame. Return (-1) if error.
 */
559 560 561 562 563
static int get_audio_frame_size(AVCodecContext *enc, int size)
{
    int frame_size;

    if (enc->frame_size <= 1) {
564 565 566
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);

        if (bits_per_sample) {
567 568
            if (enc->channels == 0)
                return -1;
569
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
570
        } else {
571 572 573 574 575 576 577 578 579 580 581 582
            /* used for example by ADPCM codecs */
            if (enc->bit_rate == 0)
                return -1;
            frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
        }
    } else {
        frame_size = enc->frame_size;
    }
    return frame_size;
}


583 584 585
/**
 * Return the frame duration in seconds, return 0 if not available.
 */
586
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
587 588 589 590 591 592
                                   AVCodecParserContext *pc, AVPacket *pkt)
{
    int frame_size;

    *pnum = 0;
    *pden = 0;
593
    switch(st->codec->codec_type) {
594
    case CODEC_TYPE_VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
595
        if(st->time_base.num*1000LL > st->time_base.den){
596 597
            *pnum = st->time_base.num;
            *pden = st->time_base.den;
598 599 600
        }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
            *pnum = st->codec->time_base.num;
            *pden = st->codec->time_base.den;
601 602 603 604
            if (pc && pc->repeat_pict) {
                *pden *= 2;
                *pnum = (*pnum) * (2 + pc->repeat_pict);
            }
605 606 607
        }
        break;
    case CODEC_TYPE_AUDIO:
608
        frame_size = get_audio_frame_size(st->codec, pkt->size);
609 610 611
        if (frame_size < 0)
            break;
        *pnum = frame_size;
612
        *pden = st->codec->sample_rate;
613 614 615 616 617 618
        break;
    default:
        break;
    }
}

619 620 621 622 623 624 625 626 627 628 629
static int is_intra_only(AVCodecContext *enc){
    if(enc->codec_type == CODEC_TYPE_AUDIO){
        return 1;
    }else if(enc->codec_type == CODEC_TYPE_VIDEO){
        switch(enc->codec_id){
        case CODEC_ID_MJPEG:
        case CODEC_ID_MJPEGB:
        case CODEC_ID_LJPEG:
        case CODEC_ID_RAWVIDEO:
        case CODEC_ID_DVVIDEO:
        case CODEC_ID_HUFFYUV:
Loren Merritt's avatar
Loren Merritt committed
630
        case CODEC_ID_FFVHUFF:
631 632 633 634 635 636 637 638 639 640
        case CODEC_ID_ASV1:
        case CODEC_ID_ASV2:
        case CODEC_ID_VCR1:
            return 1;
        default: break;
        }
    }
    return 0;
}

641
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
Michael Niedermayer's avatar
Michael Niedermayer committed
642
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
643 644 645 646
    int64_t delta= last_ts - mask/2;
    return  ((lsb - delta)&mask) + delta;
}

647
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
648 649 650
                               AVCodecParserContext *pc, AVPacket *pkt)
{
    int num, den, presentation_delayed;
651
    /* handle wrapping */
652 653 654 655 656 657
    if(st->cur_dts != AV_NOPTS_VALUE){
        if(pkt->pts != AV_NOPTS_VALUE)
            pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
        if(pkt->dts != AV_NOPTS_VALUE)
            pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
    }
658

659
    if (pkt->duration == 0) {
660
        compute_frame_duration(&num, &den, st, pc, pkt);
661
        if (den && num) {
662
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
663 664 665
        }
    }

666
    if(is_intra_only(st->codec))
667 668
        pkt->flags |= PKT_FLAG_KEY;

669 670
    /* do we have a video B frame ? */
    presentation_delayed = 0;
671
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
672 673
        /* XXX: need has_b_frame, but cannot get it if the codec is
           not initialized */
674 675
        if ((   st->codec->codec_id == CODEC_ID_H264
             || st->codec->has_b_frames) &&
676 677
            pc && pc->pict_type != FF_B_TYPE)
            presentation_delayed = 1;
678 679 680
        /* this may be redundant, but it shouldnt hurt */
        if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
            presentation_delayed = 1;
681
    }
682

683 684 685 686
    if(st->cur_dts == AV_NOPTS_VALUE){
        if(presentation_delayed) st->cur_dts = -pkt->duration;
        else                     st->cur_dts = 0;
    }
687

688
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
689 690 691 692 693
    /* interpolate PTS and DTS if they are not present */
    if (presentation_delayed) {
        /* DTS = decompression time stamp */
        /* PTS = presentation time stamp */
        if (pkt->dts == AV_NOPTS_VALUE) {
694 695 696 697 698
            /* if we know the last pts, use it */
            if(st->last_IP_pts != AV_NOPTS_VALUE)
                st->cur_dts = pkt->dts = st->last_IP_pts;
            else
                pkt->dts = st->cur_dts;
699 700 701 702 703 704 705 706 707 708
        } else {
            st->cur_dts = pkt->dts;
        }
        /* this is tricky: the dts must be incremented by the duration
           of the frame we are displaying, i.e. the last I or P frame */
        if (st->last_IP_duration == 0)
            st->cur_dts += pkt->duration;
        else
            st->cur_dts += st->last_IP_duration;
        st->last_IP_duration  = pkt->duration;
709
        st->last_IP_pts= pkt->pts;
710 711
        /* cannot compute PTS if not present (we can compute it only
           by knowing the futur */
712
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
713
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
Diego Biurrun's avatar
Diego Biurrun committed
714 715
            int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
            int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
716 717
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
                pkt->pts += pkt->duration;
718
//                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
719 720
            }
        }
721

722 723
        /* presentation is not delayed : PTS and DTS are the same */
        if (pkt->pts == AV_NOPTS_VALUE) {
724 725 726 727 728 729 730 731
            if (pkt->dts == AV_NOPTS_VALUE) {
                pkt->pts = st->cur_dts;
                pkt->dts = st->cur_dts;
            }
            else {
                st->cur_dts = pkt->dts;
                pkt->pts = pkt->dts;
            }
732 733 734 735 736 737
        } else {
            st->cur_dts = pkt->pts;
            pkt->dts = pkt->pts;
        }
        st->cur_dts += pkt->duration;
    }
738
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
739

740 741 742 743
    /* update flags */
    if (pc) {
        pkt->flags = 0;
        /* key frame computation */
744
        switch(st->codec->codec_type) {
745 746 747 748 749 750 751 752 753 754 755 756 757
        case CODEC_TYPE_VIDEO:
            if (pc->pict_type == FF_I_TYPE)
                pkt->flags |= PKT_FLAG_KEY;
            break;
        case CODEC_TYPE_AUDIO:
            pkt->flags |= PKT_FLAG_KEY;
            break;
        default:
            break;
        }
    }
}

Michael Niedermayer's avatar
Michael Niedermayer committed
758
void av_destruct_packet_nofree(AVPacket *pkt)
759 760 761 762 763 764 765
{
    pkt->data = NULL; pkt->size = 0;
}

static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
    AVStream *st;
766
    int len, ret, i;
767 768 769 770 771

    for(;;) {
        /* select current input stream component */
        st = s->cur_st;
        if (st) {
772
            if (!st->need_parsing || !st->parser) {
773 774 775 776 777
                /* no parsing needed: we just output the packet as is */
                /* raw data support */
                *pkt = s->cur_pkt;
                compute_pkt_fields(s, st, NULL, pkt);
                s->cur_st = NULL;
778
                break;
779
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
780
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
781 782 783 784
                                      s->cur_ptr, s->cur_len,
                                      s->cur_pkt.pts, s->cur_pkt.dts);
                s->cur_pkt.pts = AV_NOPTS_VALUE;
                s->cur_pkt.dts = AV_NOPTS_VALUE;
785 786 787
                /* increment read pointer */
                s->cur_ptr += len;
                s->cur_len -= len;
788

789 790
                /* return packet if any */
                if (pkt->size) {
791
                got_packet:
792 793
                    pkt->duration = 0;
                    pkt->stream_index = st->index;
794 795
                    pkt->pts = st->parser->pts;
                    pkt->dts = st->parser->dts;
796 797
                    pkt->destruct = av_destruct_packet_nofree;
                    compute_pkt_fields(s, st, st->parser, pkt);
798
                    break;
799 800
                }
            } else {
Fabrice Bellard's avatar
Fabrice Bellard committed
801
                /* free packet */
802
                av_free_packet(&s->cur_pkt);
803 804 805 806 807
                s->cur_st = NULL;
            }
        } else {
            /* read next packet */
            ret = av_read_packet(s, &s->cur_pkt);
808 809 810 811 812 813
            if (ret < 0) {
                if (ret == -EAGAIN)
                    return ret;
                /* return the last frames, if any */
                for(i = 0; i < s->nb_streams; i++) {
                    st = s->streams[i];
814
                    if (st->parser && st->need_parsing) {
815 816 817
                        av_parser_parse(st->parser, st->codec,
                                        &pkt->data, &pkt->size,
                                        NULL, 0,
818
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
819 820 821 822 823
                        if (pkt->size)
                            goto got_packet;
                    }
                }
                /* no more packets: really terminates parsing */
824
                return ret;
825
            }
826

827
            st = s->streams[s->cur_pkt.stream_index];
828
            if(st->codec->debug & FF_DEBUG_PTS)
829
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
830 831 832 833
                    s->cur_pkt.stream_index,
                    s->cur_pkt.pts,
                    s->cur_pkt.dts,
                    s->cur_pkt.size);
834 835 836 837 838

            s->cur_st = st;
            s->cur_ptr = s->cur_pkt.data;
            s->cur_len = s->cur_pkt.size;
            if (st->need_parsing && !st->parser) {
839
                st->parser = av_parser_init(st->codec->codec_id);
840 841 842
                if (!st->parser) {
                    /* no parser available : just output the raw packets */
                    st->need_parsing = 0;
843 844
                }else if(st->need_parsing == 2){
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
845 846 847 848
                }
            }
        }
    }
849
    if(st->codec->debug & FF_DEBUG_PTS)
850
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
851 852 853 854 855 856
            pkt->stream_index,
            pkt->pts,
            pkt->dts,
            pkt->size);

    return 0;
857 858 859
}

/**
860 861 862
 * Return the next frame of a stream.
 *
 * The returned packet is valid
863 864 865 866 867 868
 * until the next av_read_frame() or until av_close_input_file() and
 * must be freed with av_free_packet. For video, the packet contains
 * exactly one frame. For audio, it contains an integer number of
 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
 * data). If the audio frames have a variable size (e.g. MPEG audio),
 * then it contains one frame.
869
 *
870 871 872 873 874
 * pkt->pts, pkt->dts and pkt->duration are always set to correct
 * values in AV_TIME_BASE unit (and guessed if the format cannot
 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
 * has B frames, so it is better to rely on pkt->dts if you do not
 * decompress the payload.
875
 *
876
 * @return 0 if OK, < 0 if error or end of file.
877 878
 */
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
879 880
{
    AVPacketList *pktl;
881 882 883 884 885 886 887 888 889 890
    int eof=0;
    const int genpts= s->flags & AVFMT_FLAG_GENPTS;

    for(;;){
        pktl = s->packet_buffer;
        if (pktl) {
            AVPacket *next_pkt= &pktl->pkt;

            if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
891
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
892 893 894 895 896 897 898 899 900
                       && next_pkt->dts < pktl->pkt.dts
                       && pktl->pkt.pts != pktl->pkt.dts //not b frame
                       /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
                        next_pkt->pts= pktl->pkt.dts;
                    }
                    pktl= pktl->next;
                }
                pktl = s->packet_buffer;
            }
901 902 903

            if(   next_pkt->pts != AV_NOPTS_VALUE
               || next_pkt->dts == AV_NOPTS_VALUE
904 905 906 907 908 909 910 911 912 913 914 915 916