utils.c 99.9 KB
Newer Older
glantau's avatar
glantau committed
1
/*
diego's avatar
diego committed
2
 * various utility functions for use within FFmpeg
glantau's avatar
glantau committed
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
glantau's avatar
glantau committed
4
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
glantau's avatar
glantau 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.
glantau's avatar
glantau committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
glantau's avatar
glantau committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
glantau's avatar
glantau committed
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
glantau's avatar
glantau committed
16
 *
glantau's avatar
glantau 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
glantau's avatar
glantau committed
20
 */
glantau's avatar
glantau committed
21
#include "avformat.h"
22
#include "internal.h"
23
#include "libavcodec/opt.h"
24
#include "metadata.h"
25
#include "libavutil/avstring.h"
26
#include "riff.h"
27 28
#include <sys/time.h>
#include <time.h>
29
#include <strings.h>
30

31 32 33
#undef NDEBUG
#include <assert.h>

34 35
/**
 * @file libavformat/utils.c
diego's avatar
diego committed
36
 * various utility functions for use within FFmpeg
37 38
 */

stefano's avatar
stefano committed
39 40 41 42 43
unsigned avformat_version(void)
{
    return LIBAVFORMAT_VERSION_INT;
}

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
/* fraction handling */

/**
 * f = val + (num / den) + 0.5.
 *
 * 'num' is normalized so that it is such as 0 <= num < den.
 *
 * @param f fractional number
 * @param val integer value
 * @param num must be >= 0
 * @param den must be >= 1
 */
static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
{
    num += (den >> 1);
    if (num >= den) {
        val += num / den;
        num = num % den;
    }
    f->val = val;
    f->num = num;
    f->den = den;
}

/**
 * Fractional addition to f: f = f + (incr / f->den).
 *
 * @param f fractional number
 * @param incr increment, can be positive or negative
 */
static void av_frac_add(AVFrac *f, int64_t incr)
{
    int64_t num, den;

    num = f->num + incr;
    den = f->den;
    if (num < 0) {
        f->val += num / den;
        num = num % den;
        if (num < 0) {
            num += den;
            f->val--;
        }
    } else if (num >= den) {
        f->val += num / den;
        num = num % den;
    }
    f->num = num;
}
93

diego's avatar
diego committed
94
/** head of registered input format linked list */
95
AVInputFormat *first_iformat = NULL;
diego's avatar
diego committed
96
/** head of registered output format linked list */
97
AVOutputFormat *first_oformat = NULL;
glantau's avatar
glantau committed
98

michael's avatar
michael committed
99 100 101 102 103 104 105 106 107 108 109 110
AVInputFormat  *av_iformat_next(AVInputFormat  *f)
{
    if(f) return f->next;
    else  return first_iformat;
}

AVOutputFormat *av_oformat_next(AVOutputFormat *f)
{
    if(f) return f->next;
    else  return first_oformat;
}

111
void av_register_input_format(AVInputFormat *format)
glantau's avatar
glantau committed
112
{
113 114 115 116 117 118 119 120 121 122 123
    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;
glantau's avatar
glantau committed
124 125 126 127 128
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

129
int match_ext(const char *filename, const char *extensions)
glantau's avatar
glantau committed
130 131 132 133
{
    const char *ext, *p;
    char ext1[32], *q;

michael's avatar
michael committed
134 135
    if(!filename)
        return 0;
136

glantau's avatar
glantau committed
137 138 139 140 141 142
    ext = strrchr(filename, '.');
    if (ext) {
        ext++;
        p = extensions;
        for(;;) {
            q = ext1;
143
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
glantau's avatar
glantau committed
144 145
                *q++ = *p++;
            *q = '\0';
146
            if (!strcasecmp(ext1, ext))
glantau's avatar
glantau committed
147
                return 1;
148
            if (*p == '\0')
glantau's avatar
glantau committed
149 150 151 152 153 154 155
                break;
            p++;
        }
    }
    return 0;
}

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
static int match_format(const char *name, const char *names)
{
    const char *p;
    int len, namelen;

    if (!name || !names)
        return 0;

    namelen = strlen(name);
    while ((p = strchr(names, ','))) {
        len = FFMAX(p - names, namelen);
        if (!strncasecmp(name, names, len))
            return 1;
        names = p+1;
    }
    return !strcasecmp(name, names);
}

174
AVOutputFormat *guess_format(const char *short_name, const char *filename,
175
                             const char *mime_type)
glantau's avatar
glantau committed
176
{
177
    AVOutputFormat *fmt, *fmt_found;
glantau's avatar
glantau committed
178 179
    int score_max, score;

bellard's avatar
bellard committed
180
    /* specific test for image sequences */
181
#if CONFIG_IMAGE2_MUXER
182
    if (!short_name && filename &&
183
        av_filename_number_test(filename) &&
184 185 186
        av_guess_image2_codec(filename) != CODEC_ID_NONE) {
        return guess_format("image2", NULL, NULL);
    }
187
#endif
diego's avatar
diego committed
188
    /* Find the proper file type. */
glantau's avatar
glantau committed
189 190
    fmt_found = NULL;
    score_max = 0;
191
    fmt = first_oformat;
glantau's avatar
glantau committed
192 193 194 195 196 197
    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;
198
        if (filename && fmt->extensions &&
glantau's avatar
glantau committed
199 200 201 202 203 204 205 206 207 208
            match_ext(filename, fmt->extensions)) {
            score += 5;
        }
        if (score > score_max) {
            score_max = score;
            fmt_found = fmt;
        }
        fmt = fmt->next;
    }
    return fmt_found;
209
}
glantau's avatar
glantau committed
210

211
AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
                             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;
}

230
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
231 232 233 234
                            const char *filename, const char *mime_type, enum CodecType type){
    if(type == CODEC_TYPE_VIDEO){
        enum CodecID codec_id= CODEC_ID_NONE;

235
#if CONFIG_IMAGE2_MUXER
236
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
237 238
            codec_id= av_guess_image2_codec(filename);
        }
239
#endif
240 241 242 243 244 245 246 247 248
        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;
}

249 250 251 252
AVInputFormat *av_find_input_format(const char *short_name)
{
    AVInputFormat *fmt;
    for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
253
        if (match_format(short_name, fmt->name))
254 255 256 257 258
            return fmt;
    }
    return NULL;
}

glantau's avatar
glantau committed
259 260
/* memory handling */

261
void av_destruct_packet(AVPacket *pkt)
262 263 264 265 266
{
    av_free(pkt->data);
    pkt->data = NULL; pkt->size = 0;
}

ramiro's avatar
ramiro committed
267 268 269 270 271 272
void av_init_packet(AVPacket *pkt)
{
    pkt->pts   = AV_NOPTS_VALUE;
    pkt->dts   = AV_NOPTS_VALUE;
    pkt->pos   = -1;
    pkt->duration = 0;
michael's avatar
michael committed
273
    pkt->convergence_duration = 0;
ramiro's avatar
ramiro committed
274 275 276 277 278
    pkt->flags = 0;
    pkt->stream_index = 0;
    pkt->destruct= av_destruct_packet_nofree;
}

glantau's avatar
glantau committed
279 280
int av_new_packet(AVPacket *pkt, int size)
{
281
    uint8_t *data;
michael's avatar
michael committed
282
    if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
283
        return AVERROR(ENOMEM);
michael's avatar
michael committed
284
    data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
285
    if (!data)
286
        return AVERROR(ENOMEM);
287
    memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
michaelni's avatar
michaelni committed
288

289
    av_init_packet(pkt);
290
    pkt->data = data;
291 292
    pkt->size = size;
    pkt->destruct = av_destruct_packet;
glantau's avatar
glantau committed
293 294 295
    return 0;
}

michael's avatar
michael committed
296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
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;
}

314 315
int av_dup_packet(AVPacket *pkt)
{
316
    if (((pkt->destruct == av_destruct_packet_nofree) || (pkt->destruct == NULL)) && pkt->data) {
317
        uint8_t *data;
diego's avatar
diego committed
318
        /* We duplicate the packet and don't forget to add the padding again. */
michael's avatar
michael committed
319
        if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
320
            return AVERROR(ENOMEM);
321
        data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
322
        if (!data) {
323
            return AVERROR(ENOMEM);
324 325
        }
        memcpy(data, pkt->data, pkt->size);
326
        memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
327 328 329 330 331 332
        pkt->data = data;
        pkt->destruct = av_destruct_packet;
    }
    return 0;
}

333
int av_filename_number_test(const char *filename)
334 335
{
    char buf[1024];
336
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
337 338
}

339
static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
340 341
{
    AVInputFormat *fmt1, *fmt;
342
    int score;
343 344 345

    fmt = NULL;
    for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
346
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
347 348
            continue;
        score = 0;
349 350 351
        if (fmt1->read_probe) {
            score = fmt1->read_probe(pd);
        } else if (fmt1->extensions) {
352 353 354
            if (match_ext(pd->filename, fmt1->extensions)) {
                score = 50;
            }
355
        }
356 357
        if (score > *score_max) {
            *score_max = score;
358
            fmt = fmt1;
359 360
        }else if (score == *score_max)
            fmt = NULL;
361 362 363 364
    }
    return fmt;
}

365 366 367 368 369
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
    int score=0;
    return av_probe_input_format2(pd, is_opened, &score);
}

370 371 372 373 374 375
static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
{
    AVInputFormat *fmt;
    fmt = av_probe_input_format2(pd, 1, &score);

    if (fmt) {
376
        if (!strcmp(fmt->name, "mp3")) {
377
            st->codec->codec_id = CODEC_ID_MP3;
378 379
            st->codec->codec_type = CODEC_TYPE_AUDIO;
        } else if (!strcmp(fmt->name, "ac3")) {
380
            st->codec->codec_id = CODEC_ID_AC3;
381 382
            st->codec->codec_type = CODEC_TYPE_AUDIO;
        } else if (!strcmp(fmt->name, "mpegvideo")) {
383
            st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
384
            st->codec->codec_type = CODEC_TYPE_VIDEO;
michael's avatar
michael committed
385 386 387
        } else if (!strcmp(fmt->name, "m4v")) {
            st->codec->codec_id = CODEC_ID_MPEG4;
            st->codec->codec_type = CODEC_TYPE_VIDEO;
388
        } else if (!strcmp(fmt->name, "h264")) {
389
            st->codec->codec_id = CODEC_ID_H264;
390 391
            st->codec->codec_type = CODEC_TYPE_VIDEO;
        }
392 393 394 395
    }
    return !!fmt;
}

396 397
/************************************************************/
/* input media file */
398

399
/**
400
 * Open a media file from an IO stream. 'fmt' must be specified.
401
 */
402 403
int av_open_input_stream(AVFormatContext **ic_ptr,
                         ByteIOContext *pb, const char *filename,
404 405 406 407
                         AVInputFormat *fmt, AVFormatParameters *ap)
{
    int err;
    AVFormatContext *ic;
408 409 410 411 412 413
    AVFormatParameters default_ap;

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

415
    if(!ap->prealloced_context)
416
        ic = avformat_alloc_context();
417 418
    else
        ic = *ic_ptr;
419
    if (!ic) {
420
        err = AVERROR(ENOMEM);
421 422 423
        goto fail;
    }
    ic->iformat = fmt;
424
    ic->pb = pb;
425 426
    ic->duration = AV_NOPTS_VALUE;
    ic->start_time = AV_NOPTS_VALUE;
mru's avatar
mru committed
427
    av_strlcpy(ic->filename, filename, sizeof(ic->filename));
428 429 430 431 432

    /* allocate private data */
    if (fmt->priv_data_size > 0) {
        ic->priv_data = av_mallocz(fmt->priv_data_size);
        if (!ic->priv_data) {
433
            err = AVERROR(ENOMEM);
434 435 436 437 438 439
            goto fail;
        }
    } else {
        ic->priv_data = NULL;
    }

440
    if (ic->iformat->read_header) {
441 442 443
        err = ic->iformat->read_header(ic, ap);
        if (err < 0)
            goto fail;
444
    }
445

michael's avatar
michael committed
446
    if (pb && !ic->data_offset)
447
        ic->data_offset = url_ftell(ic->pb);
448

449 450 451 452
#if LIBAVFORMAT_VERSION_MAJOR < 53
    ff_metadata_demux_compat(ic);
#endif

453 454 455 456
    *ic_ptr = ic;
    return 0;
 fail:
    if (ic) {
457
        int i;
458
        av_freep(&ic->priv_data);
459 460 461 462 463 464 465 466
        for(i=0;i<ic->nb_streams;i++) {
            AVStream *st = ic->streams[i];
            if (st) {
                av_free(st->priv_data);
                av_free(st->codec->extradata);
            }
            av_free(st);
        }
467 468 469 470 471 472
    }
    av_free(ic);
    *ic_ptr = NULL;
    return err;
}

diego's avatar
diego committed
473
/** size of probe buffer, for guessing file type from file contents */
474
#define PROBE_BUF_MIN 2048
475
#define PROBE_BUF_MAX (1<<20)
476

477
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
478 479 480
                       AVInputFormat *fmt,
                       int buf_size,
                       AVFormatParameters *ap)
glantau's avatar
glantau committed
481
{
reimar's avatar
reimar committed
482
    int err, probe_size;
483
    AVProbeData probe_data, *pd = &probe_data;
reimar's avatar
reimar committed
484
    ByteIOContext *pb = NULL;
485

486 487 488
    pd->filename = "";
    if (filename)
        pd->filename = filename;
489
    pd->buf = NULL;
490 491 492
    pd->buf_size = 0;

    if (!fmt) {
diego's avatar
diego committed
493
        /* guess format if no file can be opened */
bellard's avatar
bellard committed
494
        fmt = av_probe_input_format(pd, 0);
glantau's avatar
glantau committed
495 496
    }

diego's avatar
diego committed
497
    /* Do not open file if the format does not need it. XXX: specific
bellard's avatar
bellard committed
498
       hack needed to handle RTSP/TCP */
reimar's avatar
reimar committed
499
    if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
bellard's avatar
bellard committed
500
        /* if no file needed do not try to open one */
501
        if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
502
            goto fail;
503
        }
504
        if (buf_size > 0) {
505
            url_setbufsize(pb, buf_size);
506
        }
507 508

        for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
509
            int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
510
            /* read probe data */
511
            pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
512
            pd->buf_size = get_buffer(pb, pd->buf, probe_size);
513
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
514
            if (url_fseek(pb, 0, SEEK_SET) < 0) {
515
                url_fclose(pb);
516
                if (url_fopen(&pb, filename, URL_RDONLY) < 0) {
reimar's avatar
reimar committed
517
                    pb = NULL;
518
                    err = AVERROR(EIO);
519 520 521
                    goto fail;
                }
            }
522
            /* guess file format */
523
            fmt = av_probe_input_format2(pd, 1, &score);
524
        }
525
        av_freep(&pd->buf);
526 527 528 529 530
    }

    /* if still no format found, error */
    if (!fmt) {
        err = AVERROR_NOFMT;
531
        goto fail;
glantau's avatar
glantau committed
532
    }
533

diego's avatar
diego committed
534
    /* check filename in case an image number is expected */
535
    if (fmt->flags & AVFMT_NEEDNUMBER) {
536
        if (!av_filename_number_test(filename)) {
bellard's avatar
bellard committed
537
            err = AVERROR_NUMEXPECTED;
538
            goto fail;
bellard's avatar
bellard committed
539 540
        }
    }
541 542 543
    err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
    if (err)
        goto fail;
544
    return 0;
glantau's avatar
glantau committed
545
 fail:
546
    av_freep(&pd->buf);
reimar's avatar
reimar committed
547
    if (pb)
548
        url_fclose(pb);
549 550
    *ic_ptr = NULL;
    return err;
551

glantau's avatar
glantau committed
552 553
}

554 555
/*******************************************************/

556 557 558
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
                               AVPacketList **plast_pktl){
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
559 560 561
    if (!pktl)
        return NULL;

562 563 564 565 566
    if (*packet_buffer)
        (*plast_pktl)->next = pktl;
    else
        *packet_buffer = pktl;

567 568 569 570 571 572
    /* add the packet in the buffered packet list */
    *plast_pktl = pktl;
    pktl->pkt= *pkt;
    return &pktl->pkt;
}

glantau's avatar
glantau committed
573
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
574
{
michael's avatar
michael committed
575 576
    int ret;
    AVStream *st;
michael's avatar
michael committed
577 578 579 580 581 582 583 584 585 586 587 588 589

    for(;;){
        AVPacketList *pktl = s->raw_packet_buffer;

        if (pktl) {
            *pkt = pktl->pkt;
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE){
                s->raw_packet_buffer = pktl->next;
                av_free(pktl);
                return 0;
            }
        }

michael's avatar
michael committed
590 591 592 593 594
        av_init_packet(pkt);
        ret= s->iformat->read_packet(s, pkt);
        if (ret < 0)
            return ret;
        st= s->streams[pkt->stream_index];
michael's avatar
michael committed
595

michael's avatar
michael committed
596 597 598 599 600 601 602 603 604 605 606
        switch(st->codec->codec_type){
        case CODEC_TYPE_VIDEO:
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
            break;
        case CODEC_TYPE_AUDIO:
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
            break;
        case CODEC_TYPE_SUBTITLE:
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
            break;
        }
michael's avatar
michael committed
607

608 609 610
        if(!pktl && st->codec->codec_id!=CODEC_ID_PROBE)
            return ret;

611
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
612

michael's avatar
michael committed
613 614 615 616 617 618 619 620
        if(st->codec->codec_id == CODEC_ID_PROBE){
            AVProbeData *pd = &st->probe_data;

            pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
            memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
            pd->buf_size += pkt->size;
            memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);

621
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
michael's avatar
michael committed
622 623 624 625 626
                set_codec_from_probe_data(st, pd, 1);
                if(st->codec->codec_id != CODEC_ID_PROBE){
                    pd->buf_size=0;
                    av_freep(&pd->buf);
                }
627
            }
michael's avatar
michael committed
628 629
        }
    }
630 631 632 633
}

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

634
/**
diego's avatar
diego committed
635
 * Get the number of samples of an audio frame. Return -1 on error.
636
 */
637 638 639 640
static int get_audio_frame_size(AVCodecContext *enc, int size)
{
    int frame_size;

641 642 643
    if(enc->codec_id == CODEC_ID_VORBIS)
        return -1;

644
    if (enc->frame_size <= 1) {
645 646 647
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);

        if (bits_per_sample) {
648 649
            if (enc->channels == 0)
                return -1;
650
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
651
        } else {
652 653 654 655 656 657 658 659 660 661 662 663
            /* 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;
}


664
/**
diego's avatar
diego committed
665
 * Return the frame duration in seconds. Return 0 if not available.
666
 */
667
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
668 669 670 671 672 673
                                   AVCodecParserContext *pc, AVPacket *pkt)
{
    int frame_size;

    *pnum = 0;
    *pden = 0;
674
    switch(st->codec->codec_type) {
675
    case CODEC_TYPE_VIDEO:
michael's avatar
michael committed
676
        if(st->time_base.num*1000LL > st->time_base.den){
michael's avatar
michael committed
677 678
            *pnum = st->time_base.num;
            *pden = st->time_base.den;
679 680 681
        }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;
682
            if (pc && pc->repeat_pict) {
683
                *pnum = (*pnum) * (1 + pc->repeat_pict);
684
            }
685 686 687
        }
        break;
    case CODEC_TYPE_AUDIO:
688
        frame_size = get_audio_frame_size(st->codec, pkt->size);
689 690 691
        if (frame_size < 0)
            break;
        *pnum = frame_size;
692
        *pden = st->codec->sample_rate;
693 694 695 696 697 698
        break;
    default:
        break;
    }
}

699 700 701 702 703 704 705 706 707 708 709
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:
lorenm's avatar
lorenm committed
710
        case CODEC_ID_FFVHUFF:
711 712 713
        case CODEC_ID_ASV1:
        case CODEC_ID_ASV2:
        case CODEC_ID_VCR1:
bcoudurier's avatar
bcoudurier committed
714
        case CODEC_ID_DNXHD:
bcoudurier's avatar
bcoudurier committed
715
        case CODEC_ID_JPEG2000:
716 717 718 719 720 721 722
            return 1;
        default: break;
        }
    }
    return 0;
}

723 724 725
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
                                      int64_t dts, int64_t pts)
{
726 727 728
    AVStream *st= s->streams[stream_index];
    AVPacketList *pktl= s->packet_buffer;

729
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
730 731 732 733 734 735 736 737 738 739 740 741 742 743
        return;

    st->first_dts= dts - st->cur_dts;
    st->cur_dts= dts;

    for(; pktl; pktl= pktl->next){
        if(pktl->pkt.stream_index != stream_index)
            continue;
        //FIXME think more about this check
        if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
            pktl->pkt.pts += st->first_dts;

        if(pktl->pkt.dts != AV_NOPTS_VALUE)
            pktl->pkt.dts += st->first_dts;
744 745 746

        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
            st->start_time= pktl->pkt.pts;
747
    }
748 749
    if (st->start_time == AV_NOPTS_VALUE)
        st->start_time = pts;
750 751
}

752 753 754
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
{
    AVPacketList *pktl= s->packet_buffer;
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
    int64_t cur_dts= 0;

    if(st->first_dts != AV_NOPTS_VALUE){
        cur_dts= st->first_dts;
        for(; pktl; pktl= pktl->next){
            if(pktl->pkt.stream_index == pkt->stream_index){
                if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
                    break;
                cur_dts -= pkt->duration;
            }
        }
        pktl= s->packet_buffer;
        st->first_dts = cur_dts;
    }else if(st->cur_dts)
        return;
770 771 772 773

    for(; pktl; pktl= pktl->next){
        if(pktl->pkt.stream_index != pkt->stream_index)
            continue;
774 775
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
           && !pktl->pkt.duration){
776
            pktl->pkt.dts= cur_dts;
777
            if(!st->codec->has_b_frames)
778 779
                pktl->pkt.pts= cur_dts;
            cur_dts += pkt->duration;
780 781 782 783
            pktl->pkt.duration= pkt->duration;
        }else
            break;
    }
784 785
    if(st->first_dts == AV_NOPTS_VALUE)
        st->cur_dts= cur_dts;
786 787
}

788
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
789 790
                               AVCodecParserContext *pc, AVPacket *pkt)
{
michael's avatar
michael committed
791
    int num, den, presentation_delayed, delay, i;
benoit's avatar
 
benoit committed
792
    int64_t offset;
793

794 795 796 797 798 799 800 801 802
    /* do we have a video B-frame ? */
    delay= st->codec->has_b_frames;
    presentation_delayed = 0;
    /* XXX: need has_b_frame, but cannot get it if the codec is
        not initialized */
    if (delay &&
        pc && pc->pict_type != FF_B_TYPE)
        presentation_delayed = 1;

803 804 805 806 807
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
       /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
        pkt->dts -= 1LL<<st->pts_wrap_bits;
    }

808 809 810 811
    // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
    // we take the conservative approach and discard both
    // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
    if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
812
        av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
813 814 815
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
    }

816
    if (pkt->duration == 0) {
817
        compute_frame_duration(&num, &den, st, pc, pkt);
818
        if (den && num) {
michael's avatar
michael committed
819
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
820

821
            if(pkt->duration != 0 && s->packet_buffer)
822
                update_initial_durations(s, st, pkt);
823 824 825
        }
    }

diego's avatar
diego committed
826 827
    /* correct timestamps with byte offset if demuxers only have timestamps
       on packet boundaries */
benoit's avatar
 
benoit committed
828 829 830 831 832 833 834 835 836
    if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
        /* this will estimate bitrate based on this frame's duration and size */
        offset = av_rescale(pc->offset, pkt->duration, pkt->size);
        if(pkt->pts != AV_NOPTS_VALUE)
            pkt->pts += offset;
        if(pkt->dts != AV_NOPTS_VALUE)
            pkt->dts += offset;
    }

837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
    if (pc && pc->dts_sync_point >= 0) {
        // we have synchronization info from the parser
        int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
        if (den > 0) {
            int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
            if (pkt->dts != AV_NOPTS_VALUE) {
                // got DTS from the stream, update reference timestamp
                st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
            } else if (st->reference_dts != AV_NOPTS_VALUE) {
                // compute DTS based on reference timestamp
                pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
                pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
            }
            if (pc->dts_sync_point > 0)
                st->reference_dts = pkt->dts; // new reference
        }
    }

diego's avatar
diego committed
856
    /* This may be redundant, but it should not hurt. */
michael's avatar
michael committed
857 858
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
        presentation_delayed = 1;
859

860
//    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);
861
    /* interpolate PTS and DTS if they are not present */
862
    if(delay==0 || (delay==1 && pc)){
michael's avatar
michael committed
863
        if (presentation_delayed) {
diego's avatar
diego committed
864 865
            /* DTS = decompression timestamp */
            /* PTS = presentation timestamp */
michael's avatar
michael committed
866
            if (pkt->dts == AV_NOPTS_VALUE)
michael's avatar
michael committed
867
                pkt->dts = st->last_IP_pts;
868
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
michael's avatar
michael committed
869 870 871 872
            if (pkt->dts == AV_NOPTS_VALUE)
                pkt->dts = st->cur_dts;

            /* this is tricky: the dts must be incremented by the duration
diego's avatar
diego committed
873
            of the frame we are displaying, i.e. the last I- or P-frame */
michael's avatar
michael committed
874 875
            if (st->last_IP_duration == 0)
                st->last_IP_duration = pkt->duration;
876
            if(pkt->dts != AV_NOPTS_VALUE)
michael's avatar
michael committed
877
                st->cur_dts = pkt->dts + st->last_IP_duration;
michael's avatar
michael committed
878 879
            st->last_IP_duration  = pkt->duration;
            st->last_IP_pts= pkt->pts;
michael's avatar
michael committed
880
            /* cannot compute PTS if not present (we can compute it only
diego's avatar
diego committed
881
            by knowing the future */
882
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
michael's avatar
michael committed
883 884 885 886 887 888 889
            if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
                int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
                int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
                if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
                    pkt->pts += pkt->duration;
    //                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);
                }
890
            }
891

michael's avatar
michael committed
892 893 894
            /* presentation is not delayed : PTS and DTS are the same */
            if(pkt->pts == AV_NOPTS_VALUE)
                pkt->pts = pkt->dts;
895
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
michael's avatar
michael committed
896 897 898
            if(pkt->pts == AV_NOPTS_VALUE)
                pkt->pts = st->cur_dts;
            pkt->dts = pkt->pts;
899
            if(pkt->pts != AV_NOPTS_VALUE)
michael's avatar
michael committed
900
                st->cur_dts = pkt->pts + pkt->duration;
michael's avatar
michael committed
901
        }
902
    }
michael's avatar
michael committed
903

904
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
michael's avatar
michael committed
905 906 907 908 909
        st->pts_buffer[0]= pkt->pts;
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
        if(pkt->dts == AV_NOPTS_VALUE)
            pkt->dts= st->pts_buffer[0];
910
        if(delay>1){
911
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
912
        }
michael's avatar
michael committed
913 914 915 916 917
        if(pkt->dts > st->cur_dts)
            st->cur_dts = pkt->dts;
    }

//    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
918

919
    /* update flags */
920 921 922
    if(is_intra_only(st->codec))
        pkt->flags |= PKT_FLAG_KEY;
    else if (pc) {
923
        pkt->flags = 0;
diego's avatar
diego committed
924
        /* keyframe computation */
925 926 927 928
        if (pc->key_frame == 1)
            pkt->flags |= PKT_FLAG_KEY;
        else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
            pkt->flags |= PKT_FLAG_KEY;
929
    }
930 931
    if (pc)
        pkt->convergence_duration = pc->convergence_duration;
932 933
}

michael's avatar
michael committed
934
void av_destruct_packet_nofree(AVPacket *pkt)
935 936 937 938 939 940 941
{
    pkt->data = NULL; pkt->size = 0;
}

static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
    AVStream *st;
942
    int len, ret, i;
943

944 945
    av_init_packet(pkt);

946 947 948 949
    for(;;) {
        /* select current input stream component */
        st = s->cur_st;
        if (st) {
950
            if (!st->need_parsing || !st->parser) {
951 952
                /* no parsing needed: we just output the packet as is */
                /* raw data support */
953
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
954 955
                compute_pkt_fields(s, st, NULL, pkt);
                s->cur_st = NULL;
michael's avatar
michael committed
956
                break;
957
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
958
                len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
959 960 961 962
                                      st->cur_ptr, st->cur_len,
                                      st->cur_pkt.pts, st->cur_pkt.dts);
                st->cur_pkt.pts = AV_NOPTS_VALUE;
                st->cur_pkt.dts = AV_NOPTS_VALUE;
963
                /* increment read pointer */
964 965
                st->cur_ptr += len;
                st->cur_len -= len;
966

967 968
                /* return packet if any */
                if (pkt->size) {
969
                    pkt->pos = st->cur_pkt.pos;              // Isn't quite accurate but close.
970
                got_packet:
971 972
                    pkt->duration = 0;
                    pkt->stream_index = st->index;
973 974
                    pkt->pts = st->parser->pts;
                    pkt->dts = st->parser->dts;
975 976
                    pkt->destruct = av_destruct_packet_nofree;
                    compute_pkt_fields(s, st, st->parser, pkt);
977 978

                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
979
                        ff_reduce_index(s, st->index);
980 981 982 983
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
                                           0, 0, AVINDEX_KEYFRAME);
                    }

michael's avatar
michael committed
984
                    break;
985 986
                }
            } else {
bellard's avatar
bellard committed
987
                /* free packet */
988
                av_free_packet(&st->cur_pkt);
989 990 991
                s->cur_st = NULL;
            }
        } else {
992
            AVPacket cur_pkt;
993
            /* read next packet */
994
            ret = av_read_packet(s, &cur_pkt);
995
            if (ret < 0) {
996
                if (ret == AVERROR(EAGAIN))
997 998 999 1000
                    return ret;
                /* return the last frames, if any */
                for(i = 0; i < s->nb_streams; i++) {
                    st = s->streams[i];
1001
                    if (st->parser && st->need_parsing) {
1002 1003 1004
                        av_parser_parse(st->parser, st->codec,
                                        &pkt->data, &pkt->size,
                                        NULL, 0,
1005
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1006 1007 1008 1009
                        if (pkt->size)
                            goto got_packet;
                    }
                }
diego's avatar
diego committed
1010
                /* no more packets: really terminate parsing */
1011
                return ret;
1012
            }
1013 1014
            st = s->streams[cur_pkt.stream_index];
            st->cur_pkt= cur_pkt;
1015

1016 1017 1018
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
               st->cur_pkt.pts < st->cur_pkt.dts){
1019
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1020 1021 1022 1023 1024
                    st->cur_pkt.stream_index,
                    st->cur_pkt.pts,
                    st->cur_pkt.dts,
                    st->cur_pkt.size);
//                av_free_packet(&st->cur_pkt);
1025 1026 1027
//                return -1;
            }

1028
            if(s->debug & FF_FDEBUG_TS)
1029
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d,  flags=%d\n",
1030 1031 1032 1033 1034
                    st->cur_pkt.stream_index,
                    st->cur_pkt.pts,
                    st->cur_pkt.dts,
                    st->cur_pkt.size,
                    st->cur_pkt.flags);
1035 1036

            s->cur_st = st;
1037 1038
            st->cur_ptr = st->cur_pkt.data;
            st->cur_len = st->cur_pkt.size;
1039
            if (st->need_parsing && !st->parser) {
1040
                st->parser = av_parser_init(st->codec->codec_id);
1041
                if (!st->parser) {
diego's avatar
diego committed
1042
                    /* no parser available: just output the raw packets */
aurel's avatar
aurel committed
1043 1044
                    st->need_parsing = AVSTREAM_PARSE_NONE;
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
michael's avatar
michael committed
1045
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1046
                }
1047
                if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1048
                    st->parser->next_frame_offset=
1049
                    st->parser->cur_offset= st->cur_pkt.pos;
1050
                }
1051 1052 1053
            }
        }
    }
1054
    if(s->debug & FF_FDEBUG_TS)
1055
        av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, flags=%d\n",
michael's avatar
michael committed
1056 1057 1058
            pkt->stream_index,
            pkt->pts,
            pkt->dts,
1059 1060
            pkt->size,
            pkt->flags);
michael's avatar
michael committed
1061 1062

    return 0;
1063 1064 1065
}

int av_read_frame(AVFormatContext *s, AVPacket *pkt)
glantau's avatar
glantau committed
1066 1067
{
    AVPacketList *pktl;
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
    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){
1078
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1079 1080 1081 1082 1083 1084 1085 1086 1087
                       && 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;
            }
1088 1089 1090

            if(   next_pkt->pts != AV_NOPTS_VALUE
               || next_pkt->dts == AV_NOPTS_VALUE
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
               || !genpts || eof){
                /* read packet from packet buffer, if there is data */
                *pkt = *next_pkt;
                s->packet_buffer = pktl->next;
                av_free(pktl);
                return 0;
            }
        }
        if(genpts){
            int ret= av_read_frame_internal(s, pkt);
            if(ret<0){
1102
                if(pktl && ret != AVERROR(EAGAIN)){
1103 1104 1105 1106 1107
                    eof=1;
                    continue;
                }else
                    return ret;
            }
1108

1109 1110
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
                                           &s->packet_buffer_end)) < 0)
1111
                return AVERROR(ENOMEM);
1112 1113 1114 1115
        }else{
            assert(!s->packet_buffer);
            return av_read_frame_internal(s, pkt);
        }
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
    }
}

/* XXX: suppress the packet queue */
static void flush_packet_queue(AVFormatContext *s)
{
    AVPacketList *pktl;

    for(;;) {
        pktl = s->packet_buffer;
1126
        if (!pktl)
1127 1128 1129 1130
            break;
        s->packet_buffer = pktl->next;
        av_free_packet(&pktl->pkt);
        av_free(pktl);
1131 1132 1133
    }
}

1134 1135 1136
/*******************************************************/
/* seek support */

1137 1138
int av_find_default_stream_index(AVFormatContext *s)
{
1139
    int first_audio_index = -1;
1140 1141 1142 1143 1144 1145 1146
    int i;
    AVStream *st;

    if (s->nb_streams <= 0)
        return -1;
    for(i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
1147
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1148 1149
            return i;
        }
1150 1151
        if (first_audio_index < 0 && st->codec->codec_type == CODEC_TYPE_AUDIO)
            first_audio_index = i;
1152
    }
1153
    return first_audio_index >= 0 ? first_audio_index : 0;
1154 1155
}

1156 1157 1158
/**
 * Flush the frame reader.
 */
1159 1160 1161 1162 1163 1164 1165
static void av_read_frame_flush(AVFormatContext *s)
{
    AVStream *st;
    int i;

    flush_packet_queue(s);

1166
    s->cur_st = NULL;
1167

1168 1169 1170
    /* for each stream, reset read state */
    for(i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
1171

1172 1173 1174
        if (st->parser) {
            av_parser_close(st->parser);
            st->parser = NULL;
1175
            av_free_packet(&st->cur_pkt);
1176
        }
michael's avatar
michael committed
1177
        st->last_IP_pts = AV_NOPTS_VALUE;
michael's avatar
michael committed
1178
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1179
        st->reference_dts = AV_NOPTS_VALUE;
1180 1181 1182
        /* fail safe */
        st->cur_ptr = NULL;
        st->cur_len = 0;
1183 1184 1185
    }
}

1186
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
michael's avatar
michael committed
1187 1188 1189
    int i;

    for(i = 0; i < s->nb_streams; i++) {
1190
        AVStream *st = s->streams[i];
michael's avatar
michael committed
1191

1192
        st->cur_dts = av_rescale(timestamp,
1193 1194
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
michael's avatar
michael committed
1195 1196 1197
    }
}

1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
void ff_reduce_index(AVFormatContext *s, int stream_index)
{
    AVStream *st= s->streams[stream_index];
    unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);

    if((unsigned)st->nb_index_entries >= max_entries){
        int i;
        for(i=0; 2*i<st->nb_index_entries; i++)
            st->index_entries[i]= st->index_entries[2*i];
        st->nb_index_entries= i;
    }
}

1211
int av_add_index_entry(AVStream *st,
michael's avatar
michael committed
1212
                            int64_t pos, int64_t timestamp, int size, int distance, int flags)
1213 1214
{
    AVIndexEntry *entries, *ie;
1215
    int index;
1216

michael's avatar
michael committed
1217 1218
    if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
        return -1;
1219

1220 1221
    entries = av_fast_realloc(st->index_entries,
                              &st->index_entries_allocated_size,
1222
                              (st->nb_index_entries + 1) *
1223
                              sizeof(AVIndexEntry));
michael's avatar
michael committed
1224 1225 1226
    if(!entries)
        return -1;

1227 1228
    st->index_entries= entries;

1229
    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1230

michael's avatar
michael committed
1231
    if(index<0){
1232 1233
        index= st->nb_index_entries++;
        ie= &entries[index];
michael's avatar
michael committed
1234 1235 1236 1237
        assert(index==0 || ie[-1].timestamp < timestamp);
    }else{
        ie= &entries[index];
        if(ie->timestamp != timestamp){
1238 1239
            if(ie->timestamp <= timestamp)
                return -1;
michael's avatar
michael committed
1240 1241
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
            st->nb_index_entries++;
diego's avatar
diego committed
1242
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
michael's avatar
michael committed
1243
            distance= ie->min_distance;
1244
    }
michael's avatar
michael committed
1245

1246 1247
    ie->pos = pos;
    ie->timestamp = timestamp;
1248
    ie->min_distance= distance;
michael's avatar
michael committed
1249
    ie->size= size;
1250
    ie->flags = flags;
1251

1252
    return index;
1253 1254
}

1255
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1256
                              int flags)
1257
{
1258 1259
    AVIndexEntry *entries= st->index_entries;
    int nb_entries= st->nb_index_entries;
1260 1261 1262
    int a, b, m;
    int64_t timestamp;

michael's avatar
michael committed
1263 1264
    a = - 1;
    b = nb_entries;
1265

michael's avatar
michael committed
1266 1267
    while (b - a > 1) {
        m = (a + b) >> 1;
1268
        timestamp = entries[m].timestamp;
michael's avatar
michael committed
1269 1270 1271
        if(timestamp >= wanted_timestamp)
            b = m;
        if(timestamp <= wanted_timestamp)
1272
            a = m;
1273
    }
1274
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1275

1276 1277 1278 1279 1280
    if(!(flags & AVSEEK_FLAG_ANY)){
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
        }
    }
michael's avatar
michael committed
1281

1282
    if(m == nb_entries)
michael's avatar
michael committed
1283 1284
        return -1;
    return  m;
1285 1286
}

benoit's avatar
benoit committed
1287
#define DEBUG_SEEK
1288

michael's avatar
michael committed
1289
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1290 1291 1292
    AVInputFormat *avif= s->iformat;
    int64_t pos_min, pos_max, pos, pos_limit;
    int64_t ts_min, ts_max, ts;
1293
    int index;
1294 1295
    AVStream *st;

1296 1297
    if (stream_index < 0)
        return -1;
1298

1299
#ifdef DEBUG_SEEK
1300
    av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1301 1302 1303 1304
#endif

    ts_max=
    ts_min= AV_NOPTS_VALUE;
diego's avatar
diego committed
1305
    pos_limit= -1; //gcc falsely says it may be uninitialized
1306 1307 1308 1309 1310

    st= s->streams[stream_index];
    if(st->index_entries){
        AVIndexEntry *e;

diego's avatar
diego committed
1311
        index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
michael's avatar
michael committed
1312
        index= FFMAX(index, 0);
1313 1314 1315 1316 1317 1318
        e= &st->index_entries[index];

        if(e->timestamp <= target_ts || e->pos == e->min_distance){
            pos_min= e->pos;
            ts_min= e->timestamp;
#ifdef DEBUG_SEEK
1319
        av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1320 1321 1322 1323 1324
               pos_min,ts_min);
#endif
        }else{
            assert(index==0);
        }
1325 1326

        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1327 1328
        assert(index < st->nb_index_entries);
        if(index >= 0){
1329 1330 1331 1332 1333 1334
            e= &st->index_entries[index];
            assert(e->timestamp >= target_ts);
            pos_max= e->pos;
            ts_max= e->timestamp;
            pos_limit= pos_max - e->min_distance;
#ifdef DEBUG_SEEK
1335
        av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1336 1337 1338 1339 1340
               pos_max,pos_limit, ts_max);
#endif
        }
    }

1341 1342 1343 1344 1345
    pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
    if(pos<0)
        return -1;

    /* do the seek */
1346
    url_fseek(s->pb, pos, SEEK_SET);
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361

    av_update_cur_dts(s, st, ts);

    return 0;
}

int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
    int64_t pos, ts;
    int64_t start_pos, filesize;
    int no_change;

#ifdef DEBUG_SEEK
    av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
#endif

1362 1363
    if(ts_min == AV_NOPTS_VALUE){
        pos_min = s->data_offset;
1364
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1365 1366 1367 1368 1369 1370
        if (ts_min == AV_NOPTS_VALUE)
            return -1;
    }

    if(ts_max == AV_NOPTS_VALUE){
        int step= 1024;
1371
        filesize = url_fsize(s->pb);
1372
        pos_max = filesize - 1;
1373 1374
        do{
            pos_max -= step;
1375
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1376 1377 1378 1379
            step += step;
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
        if (ts_max == AV_NOPTS_VALUE)
            return -1;
1380

1381 1382
        for(;;){
            int64_t tmp_pos= pos_max + 1;
1383
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1384 1385 1386 1387
            if(tmp_ts == AV_NOPTS_VALUE)
                break;
            ts_max= tmp_ts;
            pos_max= tmp_pos;
1388 1389
            if(tmp_pos >= filesize)
                break;
1390 1391 1392 1393
        }
        pos_limit= pos_max;
    }

michael's avatar
michael committed
1394 1395 1396 1397 1398 1399
    if(ts_min > ts_max){
        return -1;
    }else if(ts_min == ts_max){
        pos_limit= pos_min;
    }

1400 1401 1402
    no_change=0;
    while (pos_min < pos_limit) {
#ifdef DEBUG_SEEK
1403
        av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1404 1405 1406 1407 1408 1409 1410 1411
               pos_min, pos_max,
               ts_min, ts_max);
#endif
        assert(pos_limit <= pos_max);

        if(no_change==0){
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
            // interpolate position (better than dichotomy)
michael's avatar
michael committed
1412 1413
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
                + pos_min - approximate_keyframe_distance;
1414 1415 1416 1417
        }else if(no_change==1){
            // bisection, if interpolation failed to change min or max pos last time
            pos = (pos_min + pos_limit)>>1;
        }else{
diego's avatar
diego committed
1418 1419
            /* linear search if bisection failed, can only happen if there
               are very few or no keyframes between min/max */
1420 1421 1422 1423 1424 1425 1426 1427
            pos=pos_min;
        }
        if(pos <= pos_min)
            pos= pos_min + 1;
        else if(pos > pos_limit)
            pos= pos_limit;
        start_pos= pos;

1428
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1429 1430 1431 1432 1433
        if(pos == pos_max)
            no_change++;
        else
            no_change=0;
#ifdef DEBUG_SEEK
1434
av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1435
#endif
1436 1437 1438 1439
        if(ts == AV_NOPTS_VALUE){
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
            return -1;
        }
1440
        assert(ts != AV_NOPTS_VALUE);
michael's avatar
michael committed
1441
        if (target_ts <= ts) {
1442 1443 1444
            pos_limit = start_pos - 1;
            pos_max = pos;
            ts_max = ts;
michael's avatar
michael committed
1445 1446
        }
        if (target_ts >= ts) {
1447 1448 1449 1450
            pos_min = pos;
            ts_min = ts;
        }
    }
1451

michael's avatar
michael committed
1452 1453
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1454 1455
#ifdef DEBUG_SEEK
    pos_min = pos;
1456
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1457
    pos_min++;
1458
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1459
    av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1460 1461
           pos, ts_min, target_ts, ts_max);
#endif
1462 1463
    *ts_ret= ts;
    return pos;
1464 1465
}

michael's avatar
michael committed
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
    int64_t pos_min, pos_max;
#if 0
    AVStream *st;

    if (stream_index < 0)
        return -1;

    st= s->streams[stream_index];
#endif

    pos_min = s->data_offset;
1478
    pos_max = url_fsize(s->pb) - 1;
michael's avatar
michael committed
1479 1480 1481 1482

    if     (pos < pos_min) pos= pos_min;
    else if(pos > pos_max) pos= pos_max;

1483
    url_fseek(s->pb, pos, SEEK_SET);
michael's avatar
michael committed
1484 1485

#if 0
michael's avatar
michael committed
1486
    av_update_cur_dts(s, st, ts);
michael's avatar
michael committed
1487 1488 1489 1490
#endif
    return 0;
}

1491
static int av_seek_frame_generic(AVFormatContext *s,
michael's avatar
michael committed
1492
                                 int stream_index, int64_t timestamp, int flags)
1493
{
1494
    int index, ret;
1495 1496 1497 1498
    AVStream *st;
    AVIndexEntry *ie;

    st = s->streams[stream_index];
1499

1500
    index = av_index_search_timestamp(st, timestamp, flags);
1501

1502
    if(index < 0 || index==st->nb_index_entries-1){
1503 1504 1505
        int i;
        AVPacket pkt;

michael's avatar
michael committed
1506 1507
        if(st->nb_index_entries){
            assert(st->index_entries);
1508
            ie= &st->index_entries[st->nb_index_entries-1];
1509 1510
            if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
                return ret;
1511
            av_update_cur_dts(s, st, ie->timestamp);
1512 1513 1514 1515
        }else{
            if ((ret = url_fseek(s->pb, 0, SEEK_SET)) < 0)
                return ret;
        }
1516
        for(i=0;; i++) {
1517 1518 1519 1520
            int ret;
            do{
                ret = av_read_frame(s, &pkt);
            }while(ret == AVERROR(EAGAIN));
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
            if(ret<0)
                break;
            av_free_packet(&pkt);
            if(stream_index == pkt.stream_index){
                if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
                    break;
            }
        }
        index = av_index_search_timestamp(st, timestamp, flags);
    }
1531 1532 1533 1534
    if (index < 0)
        return -1;

    av_read_frame_flush(s);
1535 1536 1537 1538 1539
    if (s->iformat->read_seek){
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
            return 0;
    }
    ie = &st->index_entries[index];
1540 1541
    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
        return ret;
michael's avatar
michael committed
1542
    av_update_cur_dts(s, st, ie->timestamp);
1543

1544 1545 1546
    return 0;
}

michael's avatar
michael committed
1547
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1548 1549
{
    int ret;
1550
    AVStream *st;
1551

1552
    av_read_frame_flush(s);
1553

michael's avatar
michael committed
1554 1555
    if(flags & AVSEEK_FLAG_BYTE)
        return av_seek_frame_byte(s, stream_index, timestamp, flags);
1556

1557 1558 1559 1560
    if(stream_index < 0){
        stream_index= av_find_default_stream_index(s);
        if(stream_index < 0)
            return -1;
1561

michael's avatar
michael committed
1562
        st= s->streams[stream_index];
1563
       /* timestamp for default must be expressed in AV_TIME_BASE units */
michael's avatar
michael committed
1564
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1565 1566
    }

1567 1568
    /* first, we try the format specific seek */
    if (s->iformat->read_seek)
michael's avatar
michael committed
1569
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1570 1571 1572 1573 1574
    else
        ret = -1;
    if (ret >= 0) {
        return 0;
    }
1575 1576

    if(s->iformat->read_timestamp)
michael's avatar
michael committed
1577
        return av_seek_frame_binary(s, stream_index, timestamp, flags);
1578
    else
michael's avatar
michael committed
1579
        return av_seek_frame_generic(s, stream_index, timestamp, flags);
1580 1581
}

1582
/*******************************************************/
1583

1584
/**
1585
 * Returns TRUE if the stream has accurate duration in any stream.
1586
 *
1587
 * @return TRUE if the stream has accurate duration for at least one component.
1588
 */
1589
static int av_has_duration(AVFormatContext *ic)
1590 1591 1592 1593 1594 1595
{
    int i;
    AVStream *st;

    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
1596
        if (st->duration != AV_NOPTS_VALUE)
1597 1598 1599 1600 1601
            return 1;
    }
    return 0;
}

1602 1603 1604 1605 1606
/**
 * Estimate the stream timings from the one of each components.
 *
 * Also computes the global bitrate if possible.
 */
1607 1608
static void av_update_stream_timings(AVFormatContext *ic)
{
michael's avatar
michael committed
1609
    int64_t start_time, start_time1, end_time, end_time1;
1610
    int64_t duration, duration1;
1611 1612 1613
    int i;
    AVStream *st;

1614 1615
    start_time = INT64_MAX;
    end_time = INT64_MIN;
1616
    duration = INT64_MIN;
1617 1618
    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
1619
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
michael's avatar
michael committed
1620 1621 1622
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
            if (start_time1 < start_time)
                start_time = start_time1;
1623
            if (st->duration != AV_NOPTS_VALUE) {
michael's avatar
michael committed
1624 1625
                end_time1 = start_time1
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1626 1627 1628 1629
                if (end_time1 > end_time)
                    end_time = end_time1;
            }
        }
1630 1631 1632 1633 1634
        if (st->duration != AV_NOPTS_VALUE) {
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
            if (duration1 > duration)
                duration = duration1;
        }
1635
    }
1636
    if (start_time != INT64_MAX) {
1637
        ic->start_time = start_time;
1638
        if (end_time != INT64_MIN) {
1639 1640 1641 1642 1643 1644 1645
            if (end_time - start_time > duration)
                duration = end_time - start_time;
        }
    }
    if (duration != INT64_MIN) {
        ic->duration = duration;
        if (ic->file_size > 0) {
diego's avatar
diego committed
1646
            /* compute the bitrate */
1647 1648
            ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
                (double)ic->duration;
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
        }
    }
}

static void fill_all_stream_timings(AVFormatContext *ic)
{
    int i;
    AVStream *st;

    av_update_stream_timings(ic);
    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
        if (st->start_time == AV_NOPTS_VALUE) {
michael's avatar
michael committed
1662 1663 1664 1665
            if(ic->start_time != AV_NOPTS_VALUE)
                st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
            if(ic->duration != AV_NOPTS_VALUE)
                st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
        }
    }
}

static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
{
    int64_t filesize, duration;
    int bit_rate, i;
    AVStream *st;

    /* if bit_rate is already set, we believe it */
    if (ic->bit_rate == 0) {
        bit_rate = 0;
        for(i=0;i<ic->nb_streams;i++) {
            st = ic->streams[i];
1681
            bit_rate += st->codec->bit_rate;
1682 1683 1684 1685 1686
        }
        ic->bit_rate = bit_rate;
    }

    /* if duration is already set, we believe it */
1687 1688
    if (ic->duration == AV_NOPTS_VALUE &&
        ic->bit_rate != 0 &&
1689 1690 1691 1692 1693
        ic->file_size != 0)  {
        filesize = ic->file_size;
        if (filesize > 0) {
            for(i = 0; i < ic->nb_streams; i++) {
                st = ic->streams[i];
michael's avatar
michael committed
1694
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1695
                if (st->duration == AV_NOPTS_VALUE)
1696 1697 1698 1699 1700 1701 1702 1703 1704
                    st->duration = duration;
            }
        }
    }
}

#define DURATION_MAX_READ_SIZE 250000

/* only usable for MPEG-PS streams */
1705
static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1706 1707 1708 1709
{
    AVPacket pkt1, *pkt = &pkt1;
    AVStream *st;
    int read_size, i, ret;
mru's avatar
mru committed
1710
    int64_t end_time;
1711
    int64_t filesize, offset, duration;
1712

1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
    ic->cur_st = NULL;

    /* flush packet queue */
    flush_packet_queue(ic);

    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
        if (st->parser) {
            av_parser_close(st->parser);
            st->parser= NULL;
1723
            av_free_packet(&st->cur_pkt);
1724 1725
        }
    }
1726

1727 1728
    /* we read the first packets to get the first PTS (not fully
       accurate, but it is enough now) */
1729
    url_fseek(ic->pb, 0, SEEK_SET);
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742
    read_size = 0;
    for(;;) {
        if (read_size >= DURATION_MAX_READ_SIZE)
            break;
        /* if all info is available, we can stop */
        for(i = 0;i < ic->nb_streams; i++) {
            st = ic->streams[i];
            if (st->start_time == AV_NOPTS_VALUE)
                break;
        }
        if (i == ic->nb_streams)
            break;

1743 1744 1745
        do{
            ret = av_read_packet(ic, pkt);
        }while(ret == AVERROR(EAGAIN));
1746 1747 1748 1749 1750 1751
        if (ret != 0)
            break;
        read_size += pkt->size;
        st = ic->streams[pkt->stream_index];
        if (pkt->pts != AV_NOPTS_VALUE) {
            if (st->start_time == AV_NOPTS_VALUE)
michael's avatar
michael committed
1752
                st->start_time = pkt->pts;
1753 1754 1755
        }
        av_free_packet(pkt);
    }
1756 1757 1758 1759 1760 1761 1762 1763

    /* estimate the end time (duration) */
    /* XXX: may need to support wrapping */
    filesize = ic->file_size;
    offset = filesize - DURATION_MAX_READ_SIZE;
    if (offset < 0)
        offset = 0;

1764
    url_fseek(ic->pb, offset, SEEK_SET);
1765 1766 1767 1768
    read_size = 0;
    for(;;) {
        if (read_size >= DURATION_MAX_READ_SIZE)
            break;
1769

1770 1771 1772
        do{
            ret = av_read_packet(ic, pkt);
        }while(ret == AVERROR(EAGAIN));
1773 1774 1775 1776
        if (ret != 0)
            break;
        read_size += pkt->size;
        st = ic->streams[pkt->stream_index];
1777 1778
        if (pkt->pts != AV_NOPTS_VALUE &&
            st->start_time != AV_NOPTS_VALUE) {
michael's avatar
michael committed
1779
            end_time = pkt->pts;
1780 1781 1782 1783 1784 1785 1786 1787 1788
            duration = end_time - st->start_time;
            if (duration > 0) {
                if (st->duration == AV_NOPTS_VALUE ||
                    st->duration < duration)
                    st->duration = duration;
            }
        }
        av_free_packet(pkt);
    }
1789

michael's avatar
michael committed
1790
    fill_all_stream_timings(ic);
1791

1792
    url_fseek(ic->pb, old_offset, SEEK_SET);
1793 1794 1795
    for(i=0; i<ic->nb_streams; i++){
        st= ic->streams[i];
        st->cur_dts= st->first_dts;
michael's avatar
michael committed
1796
        st->last_IP_pts = AV_NOPTS_VALUE;
1797
    }
1798 1799
}

1800
static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1801 1802 1803 1804 1805 1806 1807
{
    int64_t file_size;

    /* get the file size, if possible */
    if (ic->iformat->flags & AVFMT_NOFILE) {
        file_size = 0;
    } else {
1808
        file_size = url_fsize(ic->pb);
1809 1810 1811 1812 1813
        if (file_size < 0)
            file_size = 0;
    }
    ic->file_size = file_size;

1814 1815
    if ((!strcmp(ic->iformat->name, "mpeg") ||
         !strcmp(ic->iformat->name, "mpegts")) &&
aurel's avatar
aurel committed
1816
        file_size && !url_is_streamed(ic->pb)) {
1817
        /* get accurate estimate from the PTSes */
takis's avatar
takis committed
1818
        av_estimate_timings_from_pts(ic, old_offset);
1819
    } else if (av_has_duration(ic)) {
diego's avatar
diego committed
1820
        /* at least one component has timings - we use them for all
1821 1822 1823
           the components */
        fill_all_stream_timings(ic);
    } else {
diego's avatar
diego committed
1824
        /* less precise: use bitrate info */
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
        av_estimate_timings_from_bit_rate(ic);
    }
    av_update_stream_timings(ic);

#if 0
    {
        int i;
        AVStream *st;
        for(i = 0;i < ic->nb_streams; i++) {
            st = ic->streams[i];
1835 1836
        printf("%d: start_time: %0.3f duration: %0.3f\n",
               i, (double)st->start_time / AV_TIME_BASE,
1837 1838
               (double)st->duration / AV_TIME_BASE);
        }
1839 1840
        printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
               (double)ic->start_time / AV_TIME_BASE,
1841 1842 1843 1844 1845 1846
               (double)ic->duration / AV_TIME_BASE,
               ic->bit_rate / 1000);
    }
#endif
}

1847 1848 1849 1850 1851
static int has_codec_parameters(AVCodecContext *enc)
{
    int val;
    switch(enc->codec_type) {
    case CODEC_TYPE_AUDIO:
1852
        val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1853 1854 1855
        if(!enc->frame_size &&
           (enc->codec_id == CODEC_ID_VORBIS ||
            enc->codec_id == CODEC_ID_AAC))
1856
            return 0;
1857 1858
        break;
    case CODEC_TYPE_VIDEO:
michael's avatar
michael committed
1859
        val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1860 1861 1862 1863 1864
        break;
    default:
        val = 1;
        break;
    }
1865
    return enc->codec_id != CODEC_ID_NONE && val != 0;
1866 1867
}

1868 1869 1870 1871
static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
{
    int16_t *samples;
    AVCodec *codec;
bcoudurier's avatar
bcoudurier committed
1872
    int got_picture, data_size, ret=0;
1873
    AVFrame picture;
1874

1875 1876
  if(!st->codec->codec){
    codec = avcodec_find_decoder(st->codec->codec_id);
1877 1878
    if (!codec)
        return -1;
1879
    ret = avcodec_open(st->codec, codec);
1880 1881
    if (ret < 0)
        return ret;
1882
  }
michael's avatar
michael committed
1883

1884 1885
  if(!has_codec_parameters(st->codec)){
    switch(st->codec->codec_type) {
1886
    case CODEC_TYPE_VIDEO:
1887
        ret = avcodec_decode_video(st->codec, &picture,
1888
                                   &got_picture, data, size);
1889 1890
        break;
    case CODEC_TYPE_AUDIO:
bcoudurier's avatar
bcoudurier committed
1891 1892
        data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
        samples = av_malloc(data_size);
1893 1894
        if (!samples)
            goto fail;
bcoudurier's avatar
bcoudurier committed
1895
        ret = avcodec_decode_audio2(st->codec, samples,
1896
                                    &data_size, data, size);
1897 1898 1899 1900 1901
        av_free(samples);
        break;
    default:
        break;
    }
michael's avatar
michael committed
1902
  }
1903 1904 1905 1906
 fail:
    return ret;
}

1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
unsigned int codec_get_tag(const AVCodecTag *tags, int id)
{
    while (tags->id != CODEC_ID_NONE) {
        if (tags->id == id)
            return tags->tag;
        tags++;
    }
    return 0;
}

enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
{
1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929
    int i;
    for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
        if(tag == tags[i].tag)
            return tags[i].id;
    }
    for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
        if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
           && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
           && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
           && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
            return tags[i].id;
1930 1931 1932 1933
    }
    return CODEC_ID_NONE;
}

1934
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1935 1936 1937 1938 1939 1940 1941 1942 1943
{
    int i;
    for(i=0; tags && tags[i]; i++){
        int tag= codec_get_tag(tags[i], id);
        if(tag) return tag;
    }
    return 0;
}

1944
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1945 1946 1947 1948 1949 1950 1951 1952 1953
{
    int i;
    for(i=0; tags && tags[i]; i++){
        enum CodecID id= codec_get_id(tags[i], tag);
        if(id!=CODEC_ID_NONE) return id;
    }
    return CODEC_ID_NONE;
}

1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
static void compute_chapters_end(AVFormatContext *s)
{
    unsigned int i;

    for (i=0; i+1<s->nb_chapters; i++)
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
            assert(s->chapters[i]->start <= s->chapters[i+1]->start);
            assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
            s->chapters[i]->end = s->chapters[i+1]->start;
        }

    if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
        assert(s->start_time != AV_NOPTS_VALUE);
        assert(s->duration > 0);
        s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
                                           AV_TIME_BASE_Q,
                                           s->chapters[i]->time_base);
    }
}

1974 1975 1976
/* absolute maximum size we read until we abort */
#define MAX_READ_SIZE        5000000

michael's avatar
michael committed
1977
#define MAX_STD_TIMEBASES (60*12+5)
1978 1979
static int get_std_framerate(int i){
    if(i<60*12) return i*1001;
1980
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
1981 1982
}

1983 1984 1985 1986
/*
 * Is the time base unreliable.
 * This is a heuristic to balance between quick acceptance of the values in
 * the headers vs. some extra checks.
diego's avatar
diego committed
1987 1988
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
1989 1990 1991 1992 1993
 * And there are "variable" fps files this needs to detect as well.
 */
static int tb_unreliable(AVCodecContext *c){
    if(   c->time_base.den >= 101L*c->time_base.num
       || c->time_base.den <    5L*c->time_base.num
1994 1995
/*       || c->codec_tag == AV_RL32("DIVX")
       || c->codec_tag == AV_RL32("XVID")*/
1996 1997 1998
       || c->codec_id == CODEC_ID_MPEG2VIDEO
       || c->codec_id == CODEC_ID_H264
       )
1999 2000 2001 2002
        return 1;
    return 0;
}

2003 2004
int av_find_stream_info(AVFormatContext *ic)
{
michael's avatar
michael committed
2005
    int i, count, ret, read_size, j;
2006
    AVStream *st;
2007
    AVPacket pkt1, *pkt;
2008
    int64_t last_dts[MAX_STREAMS];
michael's avatar
michael committed
2009
    int duration_count[MAX_STREAMS]={0};
2010
    double (*duration_error)[MAX_STD_TIMEBASES];
2011
    int64_t old_offset = url_ftell(ic->pb);
2012 2013
    int64_t codec_info_duration[MAX_STREAMS]={0};
    int codec_info_nb_frames[MAX_STREAMS]={0};
2014

2015
    duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2016
    if (!duration_error) return AVERROR(ENOMEM);
2017

michael's avatar
michael committed
2018 2019
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2020
        if(st->codec->codec_type == CODEC_TYPE_VIDEO){
michael's avatar
michael committed
2021 2022
/*            if(!st->time_base.num)
                st->time_base= */
2023 2024
            if(!st->codec->time_base.num)
                st->codec->time_base= st->time_base;
michael's avatar
michael committed
2025
        }
2026 2027
        //only for the split stuff
        if (!st->parser) {
2028
            st->parser = av_parser_init(st->codec->codec_id);
aurel's avatar
aurel committed
2029
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
michael's avatar
michael committed
2030 2031
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
            }
2032
        }
michael's avatar
michael committed
2033 2034
    }

2035 2036 2037
    for(i=0;i<MAX_STREAMS;i++){
        last_dts[i]= AV_NOPTS_VALUE;
    }
2038

2039 2040 2041
    count = 0;
    read_size = 0;
    for(;;) {
2042 2043 2044 2045 2046
        if(url_interrupt_cb()){
            ret= AVERROR(EINTR);
            break;
        }

2047 2048 2049
        /* check if one codec still needs to be handled */
        for(i=0;i<ic->nb_streams;i++) {
            st = ic->streams[i];
2050
            if (!has_codec_parameters(st->codec))
2051
                break;
2052
            /* variable fps and no guess at the real fps */
2053
            if(   tb_unreliable(st->codec)
2054
               && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2055
                break;
2056
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2057
                break;
2058 2059
            if(st->first_dts == AV_NOPTS_VALUE)
                break;
2060 2061 2062 2063 2064
        }
        if (i == ic->nb_streams) {
            /* NOTE: if the format has no header, then we need to read
               some packets to get most of the streams, so we cannot
               stop here */
2065
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2066 2067 2068 2069
                /* if we found the info for all the codecs, we can stop */
                ret = count;
                break;
            }
michael's avatar
michael committed
2070
        }
michael's avatar
michael committed
2071 2072 2073 2074 2075
        /* we did not get all the codec info, but we read too much data */
        if (read_size >= MAX_READ_SIZE) {
            ret = count;
            break;
        }
2076

2077 2078 2079
        /* NOTE: a new stream can be added there if no header in file
           (AVFMTCTX_NOHEADER) */
        ret = av_read_frame_internal(ic, &pkt1);
2080 2081
        if(ret == AVERROR(EAGAIN))
            continue;
2082 2083 2084
        if (ret < 0) {
            /* EOF or error */
            ret = -1; /* we could not have all the codec parameters before EOF */
2085 2086
            for(i=0;i<ic->nb_streams;i++) {
                st = ic->streams[i];
2087 2088 2089 2090
                if (!has_codec_parameters(st->codec)){
                    char buf[256];
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
                    av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
2091 2092
                } else {
                    ret = 0;
2093
                }
2094
            }
2095 2096 2097
            break;
        }

2098
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2099 2100
        if(av_dup_packet(pkt) < 0) {
            av_free(duration_error);
2101
            return AVERROR(ENOMEM);
2102
        }
2103

2104
        read_size += pkt->size;
2105 2106

        st = ic->streams[pkt->stream_index];
2107 2108
        if(codec_info_nb_frames[st->index]>1)
            codec_info_duration[st->index] += pkt->duration;
2109
        if (pkt->duration != 0)
2110
            codec_info_nb_frames[st->index]++;
2111

2112
        {
michael's avatar
michael committed
2113 2114 2115 2116 2117
            int index= pkt->stream_index;
            int64_t last= last_dts[index];
            int64_t duration= pkt->dts - last;

            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2118 2119 2120 2121
                double dur= duration * av_q2d(st->time_base);

//                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2122
                if(duration_count[index] < 2)
2123
                    memset(duration_error[index], 0, sizeof(*duration_error));
michael's avatar
michael committed
2124 2125 2126 2127 2128 2129
                for(i=1; i<MAX_STD_TIMEBASES; i++){
                    int framerate= get_std_framerate(i);
                    int ticks= lrintf(dur*framerate/(1001*12));
                    double error= dur - ticks*1001*12/(double)framerate;
                    duration_error[index][i] += error*error;
                }
2130
                duration_count[index]++;
2131
            }
michael's avatar
michael committed
2132 2133
            if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
                last_dts[pkt->stream_index]= pkt->dts;
2134
        }
2135 2136
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2137
            if(i){
2138
                st->codec->extradata_size= i;
2139
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2140
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2141
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2142 2143
            }
        }
2144

2145 2146
        /* if still no information, we try to open the codec and to
           decompress the frame. We try to avoid that in most cases as
diego's avatar
diego committed
2147 2148
           it takes longer and uses more memory. For MPEG-4, we need to
           decompress for QuickTime. */
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163
        if (!has_codec_parameters(st->codec) /*&&
            (st->codec->codec_id == CODEC_ID_FLV1 ||
             st->codec->codec_id == CODEC_ID_H264 ||
             st->codec->codec_id == CODEC_ID_H263 ||
             st->codec->codec_id == CODEC_ID_H261 ||
             st->codec->codec_id == CODEC_ID_VORBIS ||
             st->codec->codec_id == CODEC_ID_MJPEG ||
             st->codec->codec_id == CODEC_ID_PNG ||
             st->codec->codec_id == CODEC_ID_PAM ||
             st->codec->codec_id == CODEC_ID_PGM ||
             st->codec->codec_id == CODEC_ID_PGMYUV ||
             st->codec->codec_id == CODEC_ID_PBM ||
             st->codec->codec_id == CODEC_ID_PPM ||
             st->codec->codec_id == CODEC_ID_SHORTEN ||
             (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
2164
            try_decode_frame(st, pkt->data, pkt->size);
2165

2166
        if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2167
            break;
2168 2169 2170 2171
        }
        count++;
    }

diego's avatar
diego committed
2172
    // close codecs which were opened in try_decode_frame()
2173 2174
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2175 2176
        if(st->codec->codec)
            avcodec_close(st->codec);
2177
    }
2178 2179
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2180
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2181
            if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2182
                st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2183

2184
            if(duration_count[i]
2185
               && tb_unreliable(st->codec) /*&&
diego's avatar
diego committed
2186
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2187 2188 2189 2190 2191 2192 2193 2194
               st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
                double best_error= 2*av_q2d(st->time_base);
                best_error= best_error*best_error*duration_count[i]*1000*12*30;

                for(j=1; j<MAX_STD_TIMEBASES; j++){
                    double error= duration_error[i][j] * get_std_framerate(j);
//                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
michael's avatar
michael committed
2195 2196
                    if(error < best_error){
                        best_error= error;
2197
                        av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
michael's avatar
michael committed
2198
                    }
michael's avatar
michael committed
2199
                }
2200 2201
            }

michael's avatar
michael committed
2202
            if (!st->r_frame_rate.num){
2203 2204 2205 2206 2207 2208 2209 2210
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
                    <= st->codec->time_base.num * (int64_t)st->time_base.den){
                    st->r_frame_rate.num = st->codec->time_base.den;
                    st->r_frame_rate.den = st->codec->time_base.num;
                }else{
                    st->r_frame_rate.num = st->time_base.den;
                    st->r_frame_rate.den = st->time_base.num;
                }
2211
            }
2212
        }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2213 2214
            if(!st->codec->bits_per_coded_sample)
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2215
        }
glantau's avatar
glantau committed
2216
    }
2217

takis's avatar
takis committed
2218
    av_estimate_timings(ic, old_offset);
benoit's avatar
 
benoit committed
2219

2220 2221
    compute_chapters_end(ic);

2222
#if 0
diego's avatar
diego committed
2223
    /* correct DTS for B-frame streams with no timestamps */
2224 2225
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2226
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
            if(b-frames){
                ppktl = &ic->packet_buffer;
                while(ppkt1){
                    if(ppkt1->stream_index != i)
                        continue;
                    if(ppkt1->pkt->dts < 0)
                        break;
                    if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
                        break;
                    ppkt1->pkt->dts -= delta;
                    ppkt1= ppkt1->next;
                }
                if(ppkt1)
                    continue;
                st->cur_dts -= delta;
            }
        }
    }
#endif
2246 2247 2248

    av_free(duration_error);

2249
    return ret;
glantau's avatar
glantau committed
2250 2251
}

2252 2253 2254 2255
/*******************************************************/

int av_read_play(AVFormatContext *s)
{
2256 2257
    if (s->iformat->read_play)
        return s->iformat->read_play(s);
aurel's avatar
aurel committed
2258
    if (s->pb)
2259
        return av_url_read_fpause(s->pb, 0);
2260
    return AVERROR(ENOSYS);
2261 2262 2263 2264
}

int av_read_pause(AVFormatContext *s)
{
2265 2266
    if (s->iformat->read_pause)
        return s->iformat->read_pause(s);
aurel's avatar
aurel committed
2267
    if (s->pb)
2268
        return av_url_read_fpause(s->pb, 1);
2269
    return AVERROR(ENOSYS);
2270 2271
}

2272
void av_close_input_stream(AVFormatContext *s)
glantau's avatar
glantau committed
2273
{
2274
    int i;
2275
    AVStream *st;
glantau's avatar
glantau committed
2276

2277 2278
    if (s->iformat->read_close)
        s->iformat->read_close(s);
glantau's avatar
glantau committed
2279
    for(i=0;i<s->nb_streams;i++) {
2280 2281
        /* free all data in a stream component */
        st = s->streams[i];
2282 2283
        if (st->parser) {
            av_parser_close(st->parser);
2284
            av_free_packet(&st->cur_pkt);
glantau's avatar
glantau committed
2285
        }
2286
        av_metadata_free(&st->metadata);
2287
        av_free(st->index_entries);
2288
        av_free(st->codec->extradata);
2289
        av_free(st->codec);
2290
        av_free(st->filename);
2291
        av_free(st->priv_data);
2292
        av_free(st);
glantau's avatar
glantau committed
2293
    }
2294 2295 2296
    for(i=s->nb_programs-1; i>=0; i--) {
        av_freep(&s->programs[i]->provider_name);
        av_freep(&s->programs[i]->name);
2297
        av_metadata_free(&s->programs[i]->metadata);
2298
        av_freep(&s->programs[i]->stream_index);
2299 2300
        av_freep(&s->programs[i]);
    }
michael's avatar
michael committed
2301
    av_freep(&s->programs);
2302
    flush_packet_queue(s);
2303
    av_freep(&s->priv_data);
2304 2305
    while(s->nb_chapters--) {
        av_free(s->chapters[s->nb_chapters]->title);
2306
        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2307
        av_free(s->chapters[s->nb_chapters]);
2308 2309
    }
    av_freep(&s->chapters);
2310
    av_metadata_free(&s->metadata);
glantau's avatar
glantau committed
2311
    av_free(s);
glantau's avatar
glantau committed
2312 2313
}

2314 2315 2316 2317 2318 2319 2320 2321
void av_close_input_file(AVFormatContext *s)
{
    ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
    av_close_input_stream(s);
    if (pb)
        url_fclose(pb);
}

2322 2323 2324
AVStream *av_new_stream(AVFormatContext *s, int id)
{
    AVStream *st;
2325
    int i;
2326 2327 2328 2329 2330 2331 2332

    if (s->nb_streams >= MAX_STREAMS)
        return NULL;

    st = av_mallocz(sizeof(AVStream));
    if (!st)
        return NULL;
2333

2334
    st->codec= avcodec_alloc_context();
bellard's avatar
bellard committed
2335 2336
    if (s->iformat) {
        /* no default bitrate if decoding */
2337
        st->codec->bit_rate = 0;
bellard's avatar
bellard committed
2338
    }
2339 2340
    st->index = s->nb_streams;
    st->id = id;
2341 2342
    st->start_time = AV_NOPTS_VALUE;
    st->duration = AV_NOPTS_VALUE;
2343 2344 2345 2346 2347
        /* we set the current DTS to 0 so that formats without any timestamps
           but durations get some timestamps, formats with some unknown
           timestamps have their first few packets buffered and the
           timestamps corrected before they are returned to the user */
    st->cur_dts = 0;
2348
    st->first_dts = AV_NOPTS_VALUE;
2349

diego's avatar
diego committed
2350
    /* default pts setting is MPEG-like */
2351
    av_set_pts_info(st, 33, 1, 90000);
michael's avatar
michael committed
2352
    st->last_IP_pts = AV_NOPTS_VALUE;
2353 2354
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2355
    st->reference_dts = AV_NOPTS_VALUE;
2356

2357 2358
    st->sample_aspect_ratio = (AVRational){0,1};

2359 2360 2361 2362
    s->streams[s->nb_streams++] = st;
    return st;
}

2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387
AVProgram *av_new_program(AVFormatContext *ac, int id)
{
    AVProgram *program=NULL;
    int i;

#ifdef DEBUG_SI
    av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
#endif

    for(i=0; i<ac->nb_programs; i++)
        if(ac->programs[i]->id == id)
            program = ac->programs[i];

    if(!program){
        program = av_mallocz(sizeof(AVProgram));
        if (!program)
            return NULL;
        dynarray_add(&ac->programs, &ac->nb_programs, program);
        program->discard = AVDISCARD_NONE;
    }
    program->id = id;

    return program;
}

2388
AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2389
{
2390 2391 2392
    AVChapter *chapter = NULL;
    int i;

2393
    for(i=0; i<s->nb_chapters; i++)
2394 2395 2396 2397 2398
        if(s->chapters[i]->id == id)
            chapter = s->chapters[i];

    if(!chapter){
        chapter= av_mallocz(sizeof(AVChapter));
michael's avatar
michael committed
2399
        if(!chapter)
2400
            return NULL;
2401
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2402
    }
aurel's avatar
aurel committed
2403
    av_free(chapter->title);
michael's avatar
michael committed
2404
    chapter->title = av_strdup(title);
2405
    chapter->id    = id;
2406
    chapter->time_base= time_base;
2407
    chapter->start = start;
michael's avatar
michael committed
2408
    chapter->end   = end;
2409

2410
    return chapter;
2411
}
2412

2413 2414
/************************************************************/
/* output media file */
glantau's avatar
glantau committed
2415

bellard's avatar
bellard committed
2416 2417 2418
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
{
    int ret;
2419

2420 2421 2422
    if (s->oformat->priv_data_size > 0) {
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
        if (!s->priv_data)
2423
            return AVERROR(ENOMEM);
2424 2425
    } else
        s->priv_data = NULL;
2426

bellard's avatar
bellard committed
2427 2428 2429 2430 2431 2432 2433 2434
    if (s->oformat->set_parameters) {
        ret = s->oformat->set_parameters(s, ap);
        if (ret < 0)
            return ret;
    }
    return 0;
}

2435 2436
int av_write_header(AVFormatContext *s)
{
2437 2438 2439
    int ret, i;
    AVStream *st;

2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
    // some sanity checks
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];

        switch (st->codec->codec_type) {
        case CODEC_TYPE_AUDIO:
            if(st->codec->sample_rate<=0){
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
                return -1;
            }
2450 2451 2452
            if(!st->codec->block_align)
                st->codec->block_align = st->codec->channels *
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
            break;
        case CODEC_TYPE_VIDEO:
            if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
                av_log(s, AV_LOG_ERROR, "time base not set\n");
                return -1;
            }
            if(st->codec->width<=0 || st->codec->height<=0){
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
                return -1;
            }
2463 2464 2465 2466
            if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
                av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
                return -1;
            }
2467 2468
            break;
        }
2469 2470 2471 2472 2473

        if(s->oformat->codec_tag){
            if(st->codec->codec_tag){
                //FIXME
                //check that tag + id is in the table
diego's avatar
diego committed
2474
                //if neither is in the table -> OK
2475 2476 2477 2478 2479
                //if tag is in the table with another id -> FAIL
                //if id is in the table with another tag -> FAIL unless strict < ?
            }else
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
        }
2480 2481 2482 2483

        if(s->oformat->flags & AVFMT_GLOBALHEADER &&
            !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
          av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2484 2485
    }

2486
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2487 2488
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
        if (!s->priv_data)
2489
            return AVERROR(ENOMEM);
2490
    }
2491

2492
#if LIBAVFORMAT_VERSION_MAJOR < 53
2493
    ff_metadata_mux_compat(s);
2494 2495
#endif

2496 2497 2498 2499 2500
    if(s->oformat->write_header){
        ret = s->oformat->write_header(s);
        if (ret < 0)
            return ret;
    }
2501 2502 2503

    /* init PTS generation */
    for(i=0;i<s->nb_streams;i++) {
2504
        int64_t den = AV_NOPTS_VALUE;
2505 2506
        st = s->streams[i];

2507
        switch (st->codec->codec_type) {
2508
        case CODEC_TYPE_AUDIO:
2509
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2510 2511
            break;
        case CODEC_TYPE_VIDEO:
2512
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
2513 2514 2515 2516
            break;
        default:
            break;
        }
2517 2518 2519 2520 2521
        if (den != AV_NOPTS_VALUE) {
            if (den <= 0)
                return AVERROR_INVALIDDATA;
            av_frac_init(&st->pts, 0, 0, den);
        }
2522 2523
    }
    return 0;
2524 2525
}

2526
//FIXME merge with compute_pkt_fields
2527
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2528 2529
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
    int num, den, frame_size, i;
2530

2531
//    av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2532

2533 2534
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
        return -1;*/
2535

2536
    /* duration field */
2537 2538 2539 2540 2541 2542
    if (pkt->duration == 0) {
        compute_frame_duration(&num, &den, st, NULL, pkt);
        if (den && num) {
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
        }
    }
2543

2544 2545 2546
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
        pkt->pts= pkt->dts;

2547
    //XXX/FIXME this is a temporary hack until all encoders output pts
2548
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2549 2550 2551 2552 2553
        pkt->dts=
//        pkt->pts= st->cur_dts;
        pkt->pts= st->pts.val;
    }

2554
    //calculate dts from pts
2555
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2556 2557 2558 2559
        st->pts_buffer[0]= pkt->pts;
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
            st->pts_buffer[i]= (i-delay-1) * pkt->duration;
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
diego's avatar
diego committed
2560
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2561 2562

        pkt->dts= st->pts_buffer[0];
2563
    }
2564

2565
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
bcoudurier's avatar
bcoudurier committed
2566
        av_log(st->codec, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2567 2568 2569
        return -1;
    }
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
bcoudurier's avatar
bcoudurier committed
2570
        av_log(st->codec, AV_LOG_ERROR, "error, pts < dts\n");
2571 2572 2573
        return -1;
    }

2574
//    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2575 2576 2577
    st->cur_dts= pkt->dts;
    st->pts.val= pkt->dts;

2578
    /* update pts */
2579
    switch (st->codec->codec_type) {
2580
    case CODEC_TYPE_AUDIO:
2581
        frame_size = get_audio_frame_size(st->codec, pkt->size);
2582

diego's avatar
diego committed
2583 2584 2585
        /* HACK/FIXME, we skip the initial 0 size packets as they are most
           likely equal to the encoder delay, but it would be better if we
           had the real timestamps from the encoder */
2586
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2587
            av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2588
        }
2589 2590
        break;
    case CODEC_TYPE_VIDEO:
2591
        av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2592 2593 2594 2595
        break;
    default:
        break;
    }
2596
    return 0;
2597 2598 2599 2600
}

int av_write_frame(AVFormatContext *s, AVPacket *pkt)
{
2601
    int ret = compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
michael's avatar
michael committed
2602

2603
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2604
        return ret;
2605

michael's avatar
michael committed
2606 2607
    ret= s->oformat->write_packet(s, pkt);
    if(!ret)
2608
        ret= url_ferror(s->pb);
michael's avatar
michael committed
2609
    return ret;
2610 2611
}

2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640
void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
                              int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
{
    AVPacketList **next_point, *this_pktl;

    this_pktl = av_mallocz(sizeof(AVPacketList));
    this_pktl->pkt= *pkt;
    if(pkt->destruct == av_destruct_packet)
        pkt->destruct= NULL; // not shared -> must keep original from being freed
    else
        av_dup_packet(&this_pktl->pkt);  //shared -> must dup

    next_point = &s->packet_buffer;
    while(*next_point){
        if(compare(s, &(*next_point)->pkt, pkt))
            break;
        next_point= &(*next_point)->next;
    }
    this_pktl->next= *next_point;
    *next_point= this_pktl;
}

int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
{
    AVStream *st = s->streams[ pkt ->stream_index];
    AVStream *st2= s->streams[ next->stream_index];
    int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
    int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;

2641 2642 2643
    if (pkt->dts == AV_NOPTS_VALUE)
        return 0;

2644 2645 2646
    return next->dts * left > pkt->dts * right; //FIXME this can overflow
}

2647
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2648
    AVPacketList *pktl;
2649 2650 2651 2652
    int stream_count=0;
    int streams[MAX_STREAMS];

    if(pkt){
2653
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2654
    }
2655

2656 2657 2658
    memset(streams, 0, sizeof(streams));
    pktl= s->packet_buffer;
    while(pktl){
2659
//av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2660 2661 2662 2663 2664
        if(streams[ pktl->pkt.stream_index ] == 0)
            stream_count++;
        streams[ pktl->pkt.stream_index ]++;
        pktl= pktl->next;
    }
2665

2666
    if(stream_count && (s->nb_streams == stream_count || flush)){
2667 2668
        pktl= s->packet_buffer;
        *out= pktl->pkt;
2669 2670

        s->packet_buffer= pktl->next;
2671 2672 2673 2674 2675 2676 2677 2678 2679
        av_freep(&pktl);
        return 1;
    }else{
        av_init_packet(out);
        return 0;
    }
}

/**
diego's avatar
diego committed
2680
 * Interleaves an AVPacket correctly so it can be muxed.
2681 2682 2683 2684
 * @param out the interleaved packet will be output here
 * @param in the input packet
 * @param flush 1 if no further packets are available as input and all
 *              remaining packets should be output
2685
 * @return 1 if a packet was output, 0 if no packet could be output,
diego's avatar
diego committed
2686
 *         < 0 if an error occurred
2687 2688 2689 2690 2691 2692 2693 2694
 */
static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
    if(s->oformat->interleave_packet)
        return s->oformat->interleave_packet(s, out, in, flush);
    else
        return av_interleave_packet_per_dts(s, out, in, flush);
}

2695 2696 2697
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
    AVStream *st= s->streams[ pkt->stream_index];

2698
    //FIXME/XXX/HACK drop zero sized packets
2699
    if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2700
        return 0;
2701

2702
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2703
    if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2704
        return -1;
2705

2706
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2707 2708
        return -1;

2709 2710 2711 2712 2713
    for(;;){
        AVPacket opkt;
        int ret= av_interleave_packet(s, &opkt, pkt, 0);
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
            return ret;
2714

2715
        ret= s->oformat->write_packet(s, &opkt);
2716

2717 2718
        av_free_packet(&opkt);
        pkt= NULL;
2719

2720 2721
        if(ret<0)
            return ret;
2722 2723
        if(url_ferror(s->pb))
            return url_ferror(s->pb);
2724
    }
2725 2726 2727 2728
}

int av_write_trailer(AVFormatContext *s)
{
2729
    int ret, i;
2730

2731 2732 2733 2734
    for(;;){
        AVPacket pkt;
        ret= av_interleave_packet(s, &pkt, NULL, 1);
        if(ret<0) //FIXME cleanup needed for ret<0 ?
2735
            goto fail;
2736 2737
        if(!ret)
            break;
2738

2739
        ret= s->oformat->write_packet(s, &pkt);
2740

2741
        av_free_packet(&pkt);
2742

2743
        if(ret<0)
2744
            goto fail;
2745
        if(url_ferror(s->pb))
michael's avatar
michael committed
2746
            goto fail;
2747 2748
    }

2749 2750
    if(s->oformat->write_trailer)
        ret = s->oformat->write_trailer(s);
2751
fail:
michael's avatar
michael committed
2752
    if(ret == 0)
2753
       ret=url_ferror(s->pb);
2754 2755
    for(i=0;i<s->nb_streams;i++)
        av_freep(&s->streams[i]->priv_data);
2756 2757
    av_freep(&s->priv_data);
    return ret;
glantau's avatar
glantau committed
2758 2759
}

2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782
void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
{
    int i, j;
    AVProgram *program=NULL;
    void *tmp;

    for(i=0; i<ac->nb_programs; i++){
        if(ac->programs[i]->id != progid)
            continue;
        program = ac->programs[i];
        for(j=0; j<program->nb_stream_indexes; j++)
            if(program->stream_index[j] == idx)
                return;

        tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
        if(!tmp)
            return;
        program->stream_index = tmp;
        program->stream_index[program->nb_stream_indexes++] = idx;
        return;
    }
}

2783 2784 2785 2786 2787 2788 2789
static void print_fps(double d, const char *postfix){
    uint64_t v= lrintf(d*100);
    if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
    else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
    else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
}

glantau's avatar
glantau committed
2790
/* "user interface" functions */
2791
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2792
{
2793
    char buf[256];
2794 2795
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
    AVStream *st = ic->streams[i];
aurel's avatar
aurel committed
2796
    int g = av_gcd(st->time_base.num, st->time_base.den);
2797 2798 2799 2800 2801 2802 2803 2804 2805 2806
    avcodec_string(buf, sizeof(buf), st->codec, is_output);
    av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
    /* the pid is an important information, so we display it */
    /* XXX: add a generic system */
    if (flags & AVFMT_SHOW_IDS)
        av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
    if (strlen(st->language) > 0)
        av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
    av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817
    if (st->sample_aspect_ratio.num && // default
        av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
        AVRational display_aspect_ratio;
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
                  st->codec->width*st->sample_aspect_ratio.num,
                  st->codec->height*st->sample_aspect_ratio.den,
                  1024*1024);
        av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
                 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
                 display_aspect_ratio.num, display_aspect_ratio.den);
    }
2818 2819
    if(st->codec->codec_type == CODEC_TYPE_VIDEO){
        if(st->r_frame_rate.den && st->r_frame_rate.num)
2820
            print_fps(av_q2d(st->r_frame_rate), "tbr");
2821
        if(st->time_base.den && st->time_base.num)
2822
            print_fps(1/av_q2d(st->time_base), "tbn");
2823
        if(st->codec->time_base.den && st->codec->time_base.num)
2824
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
2825 2826 2827
    }
    av_log(NULL, AV_LOG_INFO, "\n");
}
glantau's avatar
glantau committed
2828 2829

void dump_format(AVFormatContext *ic,
2830
                 int index,
glantau's avatar
glantau committed
2831 2832 2833
                 const char *url,
                 int is_output)
{
2834
    int i;
glantau's avatar
glantau committed
2835

2836
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
glantau's avatar
glantau committed
2837
            is_output ? "Output" : "Input",
2838 2839
            index,
            is_output ? ic->oformat->name : ic->iformat->name,
glantau's avatar
glantau committed
2840
            is_output ? "to" : "from", url);
2841
    if (!is_output) {
2842
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
2843 2844 2845 2846 2847 2848 2849 2850
        if (ic->duration != AV_NOPTS_VALUE) {
            int hours, mins, secs, us;
            secs = ic->duration / AV_TIME_BASE;
            us = ic->duration % AV_TIME_BASE;
            mins = secs / 60;
            secs %= 60;
            hours = mins / 60;
            mins %= 60;
2851 2852
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
                   (100 * us) / AV_TIME_BASE);
2853
        } else {
2854
            av_log(NULL, AV_LOG_INFO, "N/A");
2855
        }
2856 2857
        if (ic->start_time != AV_NOPTS_VALUE) {
            int secs, us;
2858
            av_log(NULL, AV_LOG_INFO, ", start: ");
2859 2860
            secs = ic->start_time / AV_TIME_BASE;
            us = ic->start_time % AV_TIME_BASE;
2861
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
2862 2863
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
        }
2864
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2865
        if (ic->bit_rate) {
2866
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2867
        } else {
2868
            av_log(NULL, AV_LOG_INFO, "N/A");
2869
        }
2870
        av_log(NULL, AV_LOG_INFO, "\n");
2871
    }
2872 2873 2874
    if(ic->nb_programs) {
        int j, k;
        for(j=0; j<ic->nb_programs; j++) {
2875 2876
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
                   ic->programs[j]->name ? ic->programs[j]->name : "");
2877
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2878
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2879 2880
         }
    } else
2881
    for(i=0;i<ic->nb_streams;i++)
2882
        dump_stream_format(ic, i, index, is_output);
glantau's avatar
glantau committed
2883 2884
}

2885
#if LIBAVFORMAT_VERSION_MAJOR < 53
glantau's avatar
glantau committed
2886 2887
int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
{
2888
    return av_parse_video_frame_size(width_ptr, height_ptr, str);
glantau's avatar
glantau committed
2889 2890
}

2891
int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
romansh's avatar
 
romansh committed
2892
{
2893 2894 2895 2896 2897
    AVRational frame_rate;
    int ret = av_parse_video_frame_rate(&frame_rate, arg);
    *frame_rate_num= frame_rate.num;
    *frame_rate_den= frame_rate.den;
    return ret;
romansh's avatar
 
romansh committed
2898
}
2899
#endif
romansh's avatar
 
romansh committed
2900

2901 2902 2903 2904 2905 2906 2907
int64_t av_gettime(void)
{
    struct timeval tv;
    gettimeofday(&tv,NULL);
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
}

kabi's avatar
kabi committed
2908
int64_t parse_date(const char *datestr, int duration)
glantau's avatar
glantau committed
2909 2910
{
    const char *p;
kabi's avatar
kabi committed
2911
    int64_t t;
2912
    struct tm dt;
2913
    int i;
2914
    static const char * const date_fmt[] = {
2915 2916 2917
        "%Y-%m-%d",
        "%Y%m%d",
    };
2918
    static const char * const time_fmt[] = {
2919 2920 2921 2922
        "%H:%M:%S",
        "%H%M%S",
    };
    const char *q;
bellard's avatar
bellard committed
2923
    int is_utc, len;
2924
    char lastch;
michael's avatar
michael committed
2925
    int negative = 0;
2926 2927

#undef time
2928 2929
    time_t now = time(0);

bellard's avatar
bellard committed
2930 2931 2932 2933 2934
    len = strlen(datestr);
    if (len > 0)
        lastch = datestr[len - 1];
    else
        lastch = '\0';
2935
    is_utc = (lastch == 'z' || lastch == 'Z');
2936 2937

    memset(&dt, 0, sizeof(dt));
glantau's avatar
glantau committed
2938 2939

    p = datestr;
bellard's avatar
bellard committed
2940
    q = NULL;
glantau's avatar
glantau committed
2941
    if (!duration) {
2942 2943 2944
        if (!strncasecmp(datestr, "now", len))
            return (int64_t) now * 1000000;

2945
        /* parse the year-month-day part */
2946
        for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
2947
            q = small_strptime(p, date_fmt[i], &dt);
2948 2949 2950 2951 2952
            if (q) {
                break;
            }
        }

2953 2954
        /* if the year-month-day part is missing, then take the
         * current year-month-day time */
2955 2956 2957 2958 2959 2960 2961
        if (!q) {
            if (is_utc) {
                dt = *gmtime(&now);
            } else {
                dt = *localtime(&now);
            }
            dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
glantau's avatar
glantau committed
2962
        } else {
2963
            p = q;
glantau's avatar
glantau committed
2964
        }
2965 2966 2967 2968

        if (*p == 'T' || *p == 't' || *p == ' ')
            p++;

2969
        /* parse the hour-minute-second part */
2970
        for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
2971
            q = small_strptime(p, time_fmt[i], &dt);
bellard's avatar
bellard committed
2972 2973 2974 2975 2976
            if (q) {
                break;
            }
        }
    } else {
2977
        /* parse datestr as a duration */
2978 2979 2980 2981
        if (p[0] == '-') {
            negative = 1;
            ++p;
        }
2982
        /* parse datestr as HH:MM:SS */
2983
        q = small_strptime(p, time_fmt[0], &dt);
bellard's avatar
bellard committed
2984
        if (!q) {
2985
            /* parse datestr as S+ */
bellard's avatar
bellard committed
2986
            dt.tm_sec = strtol(p, (char **)&q, 10);
2987 2988 2989
            if (q == p)
                /* the parsing didn't succeed */
                return INT64_MIN;
bellard's avatar
bellard committed
2990 2991
            dt.tm_min = 0;
            dt.tm_hour = 0;
2992 2993 2994 2995 2996
        }
    }

    /* Now we have all the fields that we can get */
    if (!q) {
2997
        return INT64_MIN;
glantau's avatar
glantau committed
2998
    }
2999 3000

    if (duration) {
3001
        t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3002
    } else {
3003 3004 3005 3006 3007 3008
        dt.tm_isdst = -1;       /* unknown */
        if (is_utc) {
            t = mktimegm(&dt);
        } else {
            t = mktime(&dt);
        }
glantau's avatar
glantau committed
3009
    }
3010

3011 3012
    t *= 1000000;

3013
    /* parse the .m... part */
3014
    if (*q == '.') {
glantau's avatar
glantau committed
3015
        int val, n;
3016 3017
        q++;
        for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3018
            if (!isdigit(*q))
3019 3020
                break;
            val += n * (*q - '0');
glantau's avatar
glantau committed
3021 3022 3023
        }
        t += val;
    }
michael's avatar
michael committed
3024
    return negative ? -t : t;
glantau's avatar
glantau committed
3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046
}

int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
{
    const char *p;
    char tag[128], *q;

    p = info;
    if (*p == '?')
        p++;
    for(;;) {
        q = tag;
        while (*p != '\0' && *p != '=' && *p != '&') {
            if ((q - tag) < sizeof(tag) - 1)
                *q++ = *p;
            p++;
        }
        *q = '\0';
        q = arg;
        if (*p == '=') {
            p++;
            while (*p != '&' && *p != '\0') {
3047 3048 3049 3050 3051 3052
                if ((q - arg) < arg_size - 1) {
                    if (*p == '+')
                        *q++ = ' ';
                    else
                        *q++ = *p;
                }
glantau's avatar
glantau committed
3053 3054 3055 3056
                p++;
            }
            *q = '\0';
        }
3057
        if (!strcmp(tag, tag1))
glantau's avatar
glantau committed
3058 3059 3060
            return 1;
        if (*p != '&')
            break;
philipjsg's avatar
philipjsg committed
3061
        p++;
glantau's avatar
glantau committed
3062 3063 3064 3065
    }
    return 0;
}

3066 3067
int av_get_frame_filename(char *buf, int buf_size,
                          const char *path, int number)
glantau's avatar
glantau committed
3068 3069
{
    const char *p;
3070 3071
    char *q, buf1[20], c;
    int nd, len, percentd_found;
glantau's avatar
glantau committed
3072 3073 3074 3075 3076 3077 3078 3079 3080

    q = buf;
    p = path;
    percentd_found = 0;
    for(;;) {
        c = *p++;
        if (c == '\0')
            break;
        if (c == '%') {
3081 3082 3083 3084 3085 3086 3087 3088
            do {
                nd = 0;
                while (isdigit(*p)) {
                    nd = nd * 10 + *p++ - '0';
                }
                c = *p++;
            } while (isdigit(c));

glantau's avatar
glantau committed
3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120
            switch(c) {
            case '%':
                goto addchar;
            case 'd':
                if (percentd_found)
                    goto fail;
                percentd_found = 1;
                snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
                len = strlen(buf1);
                if ((q - buf + len) > buf_size - 1)
                    goto fail;
                memcpy(q, buf1, len);
                q += len;
                break;
            default:
                goto fail;
            }
        } else {
        addchar:
            if ((q - buf) < buf_size - 1)
                *q++ = c;
        }
    }
    if (!percentd_found)
        goto fail;
    *q = '\0';
    return 0;
 fail:
    *q = '\0';
    return -1;
}

3121
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3122 3123
{
    int len, i, j, c;
3124
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3125 3126 3127 3128 3129

    for(i=0;i<size;i+=16) {
        len = size - i;
        if (len > 16)
            len = 16;
3130
        PRINT("%08x ", i);
3131 3132
        for(j=0;j<16;j++) {
            if (j < len)
3133
                PRINT(" %02x", buf[i+j]);
3134
            else
3135
                PRINT("   ");
3136
        }
3137
        PRINT(" ");
3138 3139 3140 3141
        for(j=0;j<len;j++) {
            c = buf[i+j];
            if (c < ' ' || c > '~')
                c = '.';
3142
            PRINT("%c", c);
3143
        }
3144
        PRINT("\n");
3145
    }
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156
#undef PRINT
}

void av_hex_dump(FILE *f, uint8_t *buf, int size)
{
    hex_dump_internal(NULL, f, 0, buf, size);
}

void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
{
    hex_dump_internal(avcl, NULL, level, buf, size);
3157 3158
}

michael's avatar
michael committed
3159
 //FIXME needs to know the time_base
3160
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3161
{
3162 3163 3164 3165
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
    PRINT("stream #%d:\n", pkt->stream_index);
    PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
    PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3166
    /* DTS is _always_ valid after av_read_frame() */
3167
    PRINT("  dts=");
3168
    if (pkt->dts == AV_NOPTS_VALUE)
3169
        PRINT("N/A");
3170
    else
3171
        PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
diego's avatar
diego committed
3172
    /* PTS may not be known if B-frames are present. */
3173
    PRINT("  pts=");
3174
    if (pkt->pts == AV_NOPTS_VALUE)
3175
        PRINT("N/A");
3176
    else
3177 3178 3179 3180
        PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
    PRINT("\n");
    PRINT("  size=%d\n", pkt->size);
#undef PRINT
3181 3182 3183 3184
    if (dump_payload)
        av_hex_dump(f, pkt->data, pkt->size);
}

3185 3186 3187 3188 3189 3190 3191 3192 3193 3194
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
{
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
}

void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
{
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
}

bellard's avatar
bellard committed
3195
void url_split(char *proto, int proto_size,
3196
               char *authorization, int authorization_size,
bellard's avatar
bellard committed
3197 3198 3199 3200 3201
               char *hostname, int hostname_size,
               int *port_ptr,
               char *path, int path_size,
               const char *url)
{
3202
    const char *p, *ls, *at, *col, *brk;
3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215

    if (port_ptr)               *port_ptr = -1;
    if (proto_size > 0)         proto[0] = 0;
    if (authorization_size > 0) authorization[0] = 0;
    if (hostname_size > 0)      hostname[0] = 0;
    if (path_size > 0)          path[0] = 0;

    /* parse protocol */
    if ((p = strchr(url, ':'))) {
        av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
        p++; /* skip ':' */
        if (*p == '/') p++;
        if (*p == '/') p++;
bellard's avatar
bellard committed
3216
    } else {
3217 3218 3219 3220
        /* no protocol means plain filename */
        av_strlcpy(path, url, path_size);
        return;
    }
3221

3222
    /* separate path from hostname */
3223 3224 3225 3226
    ls = strchr(p, '/');
    if(!ls)
        ls = strchr(p, '?');
    if(ls)
michael's avatar
michael committed
3227
        av_strlcpy(path, ls, path_size);
3228
    else
3229 3230 3231 3232 3233 3234 3235 3236 3237
        ls = &p[strlen(p)]; // XXX

    /* the rest is hostname, use that to parse auth/port */
    if (ls != p) {
        /* authorization (user[:pass]@hostname) */
        if ((at = strchr(p, '@')) && at < ls) {
            av_strlcpy(authorization, p,
                       FFMIN(authorization_size, at + 1 - p));
            p = at + 1; /* skip '@' */
bellard's avatar
bellard committed
3238
        }
3239

andoma's avatar
andoma committed
3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
        if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
            /* [host]:port */
            av_strlcpy(hostname, p + 1,
                       FFMIN(hostname_size, brk - p));
            if (brk[1] == ':' && port_ptr)
                *port_ptr = atoi(brk + 2);
        } else if ((col = strchr(p, ':')) && col < ls) {
            av_strlcpy(hostname, p,
                       FFMIN(col + 1 - p, hostname_size));
            if (port_ptr) *port_ptr = atoi(col + 1);
        } else
            av_strlcpy(hostname, p,
                       FFMIN(ls + 1 - p, hostname_size));
bellard's avatar
bellard committed
3253 3254 3255
    }
}

3256 3257 3258
char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
{
    int i;
3259 3260 3261 3262
    static const char hex_table[16] = { '0', '1', '2', '3',
                                        '4', '5', '6', '7',
                                        '8', '9', 'A', 'B',
                                        'C', 'D', 'E', 'F' };
3263 3264

    for(i = 0; i < s; i++) {
3265 3266
        buff[i * 2]     = hex_table[src[i] >> 4];
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3267 3268 3269 3270 3271
    }

    return buff;
}

3272
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
bellard's avatar
bellard committed
3273 3274
                     int pts_num, int pts_den)
{
aurel's avatar
aurel committed
3275
    unsigned int gcd= av_gcd(pts_num, pts_den);
bellard's avatar
bellard committed
3276
    s->pts_wrap_bits = pts_wrap_bits;
3277 3278 3279 3280 3281
    s->time_base.num = pts_num/gcd;
    s->time_base.den = pts_den/gcd;

    if(gcd>1)
        av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, gcd);
bellard's avatar
bellard committed
3282
}