utils.c 92 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;
Fabrice Bellard's avatar
Fabrice Bellard committed
41

42
void av_register_input_format(AVInputFormat *format)
Fabrice Bellard's avatar
Fabrice Bellard committed
43
{
44 45 46 47 48 49 50 51 52 53 54
    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
55 56 57 58 59
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

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

Michael Niedermayer's avatar
Michael Niedermayer committed
65 66
    if(!filename)
        return 0;
67

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

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

Fabrice Bellard's avatar
Fabrice Bellard committed
93
    /* specific test for image sequences */
94
#ifdef CONFIG_IMAGE2_MUXER
95
    if (!short_name && filename &&
96
        av_filename_number_test(filename) &&
97 98 99
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
        return guess_format("image2", NULL, NULL);
    }
100
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
101 102 103
    /* find the proper file type */
    fmt_found = NULL;
    score_max = 0;
104
    fmt = first_oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
105 106 107 108 109 110
    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;
111
        if (filename && fmt->extensions &&
Fabrice Bellard's avatar
Fabrice Bellard committed
112 113 114 115 116 117 118 119 120 121
            match_ext(filename, fmt->extensions)) {
            score += 5;
        }
        if (score > score_max) {
            score_max = score;
            fmt_found = fmt;
        }
        fmt = fmt->next;
    }
    return fmt_found;
122
}
Fabrice Bellard's avatar
Fabrice Bellard committed
123

124
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
                             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;
}

143
/**
144
 * Guesses the codec id based upon muxer and filename.
145
 */
146
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
147 148 149 150
                            const char *filename, const char *mime_type, enum CodecType type){
    if(type == CODEC_TYPE_VIDEO){
        enum CodecID codec_id= CODEC_ID_NONE;

151
#ifdef CONFIG_IMAGE2_MUXER
152
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
153 154
            codec_id= av_guess_image2_codec(filename);
        }
155
#endif
156 157 158 159 160 161 162 163 164
        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;
}

165 166 167
/**
 * finds AVInputFormat based on input format's short name.
 */
168 169 170 171 172 173 174 175 176 177
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
178 179
/* memory handling */

180
/**
181
 * Default packet destructor.
182
 */
183
void av_destruct_packet(AVPacket *pkt)
184 185 186 187 188
{
    av_free(pkt->data);
    pkt->data = NULL; pkt->size = 0;
}

189 190 191 192 193 194 195
/**
 * 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
196 197
int av_new_packet(AVPacket *pkt, int size)
{
198
    uint8_t *data;
199
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
200
        return AVERROR_NOMEM;
201
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
202
    if (!data)
203
        return AVERROR_NOMEM;
204
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
205

206
    av_init_packet(pkt);
207
    pkt->data = data;
208 209
    pkt->size = size;
    pkt->destruct = av_destruct_packet;
Fabrice Bellard's avatar
Fabrice Bellard committed
210 211 212
    return 0;
}

Michael Niedermayer's avatar
Michael Niedermayer committed
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
/**
 * 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;
}

238 239 240 241 242 243
/* 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;
244 245
        /* we duplicate the packet and don't forget to put the padding
           again */
246
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
247
            return AVERROR_NOMEM;
248
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
249 250 251 252
        if (!data) {
            return AVERROR_NOMEM;
        }
        memcpy(data, pkt->data, pkt->size);
253
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
254 255 256 257 258 259
        pkt->data = data;
        pkt->destruct = av_destruct_packet;
    }
    return 0;
}

260 261 262 263 264 265 266
/**
 * 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)
267 268
{
    char buf[1024];
269
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
270 271
}

272 273 274
/**
 * Guess file format.
 */
275
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
276 277 278 279 280 281 282 283 284 285
{
    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;
286 287 288
        if (fmt1->read_probe) {
            score = fmt1->read_probe(pd);
        } else if (fmt1->extensions) {
289 290 291
            if (match_ext(pd->filename, fmt1->extensions)) {
                score = 50;
            }
292
        }
293 294 295 296 297 298 299 300 301 302
        if (score > score_max) {
            score_max = score;
            fmt = fmt1;
        }
    }
    return fmt;
}

/************************************************************/
/* input media file */
303

304
/**
305
 * Open a media file from an IO stream. 'fmt' must be specified.
306
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
307
static const char* format_to_name(void* ptr)
308
{
Michael Niedermayer's avatar
Michael Niedermayer committed
309
    AVFormatContext* fc = (AVFormatContext*) ptr;
310 311 312 313 314
    if(fc->iformat) return fc->iformat->name;
    else if(fc->oformat) return fc->oformat->name;
    else return "NULL";
}

315
#define OFFSET(x) offsetof(AVFormatContext,x)
316 317 318 319 320 321
#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[]={
322
{"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
323
{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
324
{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
325
{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
326 327
{"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"},
328
{"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
329
{"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
330 331 332
{NULL},
};

333 334 335 336
#undef E
#undef D
#undef DEFAULT

337 338
static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };

Michael Niedermayer's avatar
Michael Niedermayer committed
339
#if LIBAVFORMAT_VERSION_INT >= ((51<<16)+(0<<8)+0)
340 341
static
#endif
342 343
void avformat_get_context_defaults(AVFormatContext *s){
    memset(s, 0, sizeof(AVFormatContext));
344

345 346 347
    s->av_class = &av_format_context_class;

    av_opt_set_defaults(s);
348
}
349 350 351 352

AVFormatContext *av_alloc_format_context(void)
{
    AVFormatContext *ic;
353
    ic = av_malloc(sizeof(AVFormatContext));
354
    if (!ic) return ic;
355
    avformat_get_context_defaults(ic);
Michael Niedermayer's avatar
Michael Niedermayer committed
356
    ic->av_class = &av_format_context_class;
357 358 359
    return ic;
}

360 361 362 363
/**
 * Allocates all the structures needed to read an input stream.
 *        This does not open the needed codecs for decoding the stream[s].
 */
364 365
int av_open_input_stream(AVFormatContext **ic_ptr,
                         ByteIOContext *pb, const char *filename,
366 367 368 369
                         AVInputFormat *fmt, AVFormatParameters *ap)
{
    int err;
    AVFormatContext *ic;
370 371 372 373 374 375
    AVFormatParameters default_ap;

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

377 378 379 380
    if(!ap->prealloced_context)
        ic = av_alloc_format_context();
    else
        ic = *ic_ptr;
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
    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;
406

407
    if (pb && !ic->data_offset)
408 409
        ic->data_offset = url_ftell(&ic->pb);

410 411 412 413 414 415 416 417 418 419 420
    *ic_ptr = ic;
    return 0;
 fail:
    if (ic) {
        av_freep(&ic->priv_data);
    }
    av_free(ic);
    *ic_ptr = NULL;
    return err;
}

421
/** Size of probe buffer, for guessing file type from file contents. */
422
#define PROBE_BUF_MIN 2048
423
#define PROBE_BUF_MAX (1<<20)
424 425 426 427 428 429 430 431 432 433 434 435

/**
 * 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.
 */
436
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
437 438 439
                       AVInputFormat *fmt,
                       int buf_size,
                       AVFormatParameters *ap)
Fabrice Bellard's avatar
Fabrice Bellard committed
440
{
441
    int err, must_open_file, file_opened, probe_size;
442
    AVProbeData probe_data, *pd = &probe_data;
443
    ByteIOContext pb1, *pb = &pb1;
444

445 446 447 448
    file_opened = 0;
    pd->filename = "";
    if (filename)
        pd->filename = filename;
449
    pd->buf = NULL;
450 451 452 453
    pd->buf_size = 0;

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

Fabrice Bellard's avatar
Fabrice Bellard committed
457 458 459
    /* do not open file if the format does not need it. XXX: specific
       hack needed to handle RTSP/TCP */
    must_open_file = 1;
460
    if (fmt && (fmt->flags & AVFMT_NOFILE)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
461
        must_open_file = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
462
        pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
Fabrice Bellard's avatar
Fabrice Bellard committed
463 464 465
    }

    if (!fmt || must_open_file) {
Fabrice Bellard's avatar
Fabrice Bellard committed
466
        /* if no file needed do not try to open one */
467
        if (url_fopen(pb, filename, URL_RDONLY) < 0) {
468
            err = AVERROR_IO;
469
            goto fail;
470
        }
471
        file_opened = 1;
472
        if (buf_size > 0) {
473
            url_setbufsize(pb, buf_size);
474
        }
475 476

        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
477
            /* read probe data */
478 479
            pd->buf= av_realloc(pd->buf, probe_size);
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
480 481 482
            if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
                url_fclose(pb);
                if (url_fopen(pb, filename, URL_RDONLY) < 0) {
483
                    file_opened = 0;
484 485 486 487
                    err = AVERROR_IO;
                    goto fail;
                }
            }
488 489
            /* guess file format */
            fmt = av_probe_input_format(pd, 1);
490
        }
491
        av_freep(&pd->buf);
492 493 494 495 496
    }

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

500
    /* XXX: suppress this hack for redirectors */
501
#ifdef CONFIG_NETWORK
502
    if (fmt == &redir_demuxer) {
503 504
        err = redir_open(ic_ptr, pb);
        url_fclose(pb);
505 506
        return err;
    }
507
#endif
508

Fabrice Bellard's avatar
Fabrice Bellard committed
509
    /* check filename in case of an image number is expected */
510
    if (fmt->flags & AVFMT_NEEDNUMBER) {
511
        if (!av_filename_number_test(filename)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
512
            err = AVERROR_NUMEXPECTED;
513
            goto fail;
Fabrice Bellard's avatar
Fabrice Bellard committed
514 515
        }
    }
516 517 518
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
    if (err)
        goto fail;
519
    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
520
 fail:
521
    av_freep(&pd->buf);
522 523
    if (file_opened)
        url_fclose(pb);
524 525
    *ic_ptr = NULL;
    return err;
526

Fabrice Bellard's avatar
Fabrice Bellard committed
527 528
}

529 530
/*******************************************************/

531
/**
532 533 534 535
 * Read a transport packet from a media file.
 *
 * This function is absolete and should never be used.
 * Use av_read_frame() instead.
536
 *
537
 * @param s media file handle
538 539
 * @param pkt is filled
 * @return 0 if OK. AVERROR_xxx if error.
540
 */
Fabrice Bellard's avatar
Fabrice Bellard committed
541
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
542 543 544 545 546 547
{
    return s->iformat->read_packet(s, pkt);
}

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

548 549 550
/**
 * Get the number of samples of an audio frame. Return (-1) if error.
 */
551 552 553 554 555
static int get_audio_frame_size(AVCodecContext *enc, int size)
{
    int frame_size;

    if (enc->frame_size <= 1) {
556 557 558
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);

        if (bits_per_sample) {
559 560
            if (enc->channels == 0)
                return -1;
561
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
562
        } else {
563 564 565 566 567 568 569 570 571 572 573 574
            /* 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;
}


575 576 577
/**
 * Return the frame duration in seconds, return 0 if not available.
 */
578
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
579 580 581 582 583 584
                                   AVCodecParserContext *pc, AVPacket *pkt)
{
    int frame_size;

    *pnum = 0;
    *pden = 0;
585
    switch(st->codec->codec_type) {
586
    case CODEC_TYPE_VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
587
        if(st->time_base.num*1000LL > st->time_base.den){
588 589
            *pnum = st->time_base.num;
            *pden = st->time_base.den;
590 591 592
        }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;
593 594 595 596
            if (pc && pc->repeat_pict) {
                *pden *= 2;
                *pnum = (*pnum) * (2 + pc->repeat_pict);
            }
597 598 599
        }
        break;
    case CODEC_TYPE_AUDIO:
600
        frame_size = get_audio_frame_size(st->codec, pkt->size);
601 602 603
        if (frame_size < 0)
            break;
        *pnum = frame_size;
604
        *pden = st->codec->sample_rate;
605 606 607 608 609 610
        break;
    default:
        break;
    }
}

611 612 613 614 615 616 617 618 619 620 621
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
622
        case CODEC_ID_FFVHUFF:
623 624 625 626 627 628 629 630 631 632
        case CODEC_ID_ASV1:
        case CODEC_ID_ASV2:
        case CODEC_ID_VCR1:
            return 1;
        default: break;
        }
    }
    return 0;
}

633
static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
Michael Niedermayer's avatar
Michael Niedermayer committed
634
    int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
635 636 637 638
    int64_t delta= last_ts - mask/2;
    return  ((lsb - delta)&mask) + delta;
}

639
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
640 641 642
                               AVCodecParserContext *pc, AVPacket *pkt)
{
    int num, den, presentation_delayed;
643
    /* handle wrapping */
644 645 646 647 648 649
    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);
    }
650

651
    if (pkt->duration == 0) {
652
        compute_frame_duration(&num, &den, st, pc, pkt);
653
        if (den && num) {
654
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
655 656 657
        }
    }

658
    if(is_intra_only(st->codec))
659 660
        pkt->flags |= PKT_FLAG_KEY;

661 662
    /* do we have a video B frame ? */
    presentation_delayed = 0;
663
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
664 665
        /* XXX: need has_b_frame, but cannot get it if the codec is
           not initialized */
666 667
        if ((   st->codec->codec_id == CODEC_ID_H264
             || st->codec->has_b_frames) &&
668 669
            pc && pc->pict_type != FF_B_TYPE)
            presentation_delayed = 1;
670 671 672
        /* 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;
673
    }
674

675 676 677 678
    if(st->cur_dts == AV_NOPTS_VALUE){
        if(presentation_delayed) st->cur_dts = -pkt->duration;
        else                     st->cur_dts = 0;
    }
679

680
//    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
681 682 683 684 685
    /* 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) {
686 687 688 689 690
            /* 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;
691 692 693 694 695 696 697 698 699 700
        } 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;
701
        st->last_IP_pts= pkt->pts;
702 703
        /* cannot compute PTS if not present (we can compute it only
           by knowing the futur */
704
    } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
705
        if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
Diego Biurrun's avatar
Diego Biurrun committed
706 707
            int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
            int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
708 709
            if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
                pkt->pts += pkt->duration;
710
//                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
711 712
            }
        }
713

714 715
        /* presentation is not delayed : PTS and DTS are the same */
        if (pkt->pts == AV_NOPTS_VALUE) {
716 717 718 719 720 721 722 723
            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;
            }
724 725 726 727 728 729
        } else {
            st->cur_dts = pkt->pts;
            pkt->dts = pkt->pts;
        }
        st->cur_dts += pkt->duration;
    }
730
//    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
731

732 733 734 735
    /* update flags */
    if (pc) {
        pkt->flags = 0;
        /* key frame computation */
736
        switch(st->codec->codec_type) {
737 738 739 740 741 742 743 744 745 746 747 748 749
        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
750
void av_destruct_packet_nofree(AVPacket *pkt)
751 752 753 754 755 756 757
{
    pkt->data = NULL; pkt->size = 0;
}

static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
    AVStream *st;
758
    int len, ret, i;
759 760 761 762 763

    for(;;) {
        /* select current input stream component */
        st = s->cur_st;
        if (st) {
764
            if (!st->need_parsing || !st->parser) {
765 766 767 768 769
                /* 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;
770
                break;
771
            } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
772
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
773 774 775 776
                                      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;
777 778 779
                /* increment read pointer */
                s->cur_ptr += len;
                s->cur_len -= len;
780

781 782
                /* return packet if any */
                if (pkt->size) {
783
                got_packet:
784 785
                    pkt->duration = 0;
                    pkt->stream_index = st->index;
786 787
                    pkt->pts = st->parser->pts;
                    pkt->dts = st->parser->dts;
788 789
                    pkt->destruct = av_destruct_packet_nofree;
                    compute_pkt_fields(s, st, st->parser, pkt);
790
                    break;
791 792
                }
            } else {
Fabrice Bellard's avatar
Fabrice Bellard committed
793
                /* free packet */
794
                av_free_packet(&s->cur_pkt);
795 796 797 798 799
                s->cur_st = NULL;
            }
        } else {
            /* read next packet */
            ret = av_read_packet(s, &s->cur_pkt);
800 801 802 803 804 805
            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];
806
                    if (st->parser && st->need_parsing) {
807 808 809
                        av_parser_parse(st->parser, st->codec,
                                        &pkt->data, &pkt->size,
                                        NULL, 0,
810
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
811 812 813 814 815
                        if (pkt->size)
                            goto got_packet;
                    }
                }
                /* no more packets: really terminates parsing */
816
                return ret;
817
            }
818

819
            st = s->streams[s->cur_pkt.stream_index];
820
            if(st->codec->debug & FF_DEBUG_PTS)
821
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
822 823 824 825
                    s->cur_pkt.stream_index,
                    s->cur_pkt.pts,
                    s->cur_pkt.dts,
                    s->cur_pkt.size);
826 827 828 829 830

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

    return 0;
849 850 851
}

/**
852 853 854
 * Return the next frame of a stream.
 *
 * The returned packet is valid
855 856 857 858 859 860
 * 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.
861
 *
862 863 864 865 866
 * 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.
867
 *
868
 * @return 0 if OK, < 0 if error or end of file.
869 870
 */
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
871 872
{
    AVPacketList *pktl;
873 874 875 876 877 878 879 880 881 882
    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){
883
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
884 885 886 887 888 889 890 891 892
                       && 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;
            }
893 894 895

            if(   next_pkt->pts != AV_NOPTS_VALUE
               || next_pkt->dts == AV_NOPTS_VALUE