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

/* #define DEBUG */

Fabrice Bellard's avatar
Fabrice Bellard committed
24
#include "avformat.h"
25
#include "avio_internal.h"
26
#include "internal.h"
27
#include "libavcodec/internal.h"
28
#include "libavcodec/bytestream.h"
29
#include "libavutil/opt.h"
30
#include "libavutil/dict.h"
31
#include "libavutil/pixdesc.h"
32
#include "metadata.h"
33
#include "id3v2.h"
34
#include "libavutil/avstring.h"
35
#include "libavutil/mathematics.h"
36
#include "libavutil/parseutils.h"
37
#include "riff.h"
38
#include "audiointerleave.h"
39
#include "url.h"
40 41
#include <sys/time.h>
#include <time.h>
42 43 44 45
#include <stdarg.h>
#if CONFIG_NETWORK
#include "network.h"
#endif
46

47 48 49
#undef NDEBUG
#include <assert.h>

50
/**
51
 * @file
52
 * various utility functions for use within Libav
53 54
 */

55 56 57 58 59
unsigned avformat_version(void)
{
    return LIBAVFORMAT_VERSION_INT;
}

60
const char *avformat_configuration(void)
61
{
62
    return LIBAV_CONFIGURATION;
63 64
}

65
const char *avformat_license(void)
66 67
{
#define LICENSE_PREFIX "libavformat license: "
68
    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
69 70
}

71 72 73 74 75 76 77 78 79 80 81 82
/* 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
 */
83
static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
{
    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
 */
101
static void frac_add(AVFrac *f, int64_t incr)
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
{
    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;
}
120

121
/** head of registered input format linked list */
122
static AVInputFormat *first_iformat = NULL;
123
/** head of registered output format linked list */
124
static AVOutputFormat *first_oformat = NULL;
Fabrice Bellard's avatar
Fabrice Bellard committed
125

126 127 128 129 130 131 132 133 134 135 136 137
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;
}

138
void av_register_input_format(AVInputFormat *format)
Fabrice Bellard's avatar
Fabrice Bellard committed
139
{
140 141 142 143 144 145 146 147 148 149 150
    AVInputFormat **p;
    p = &first_iformat;
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

void av_register_output_format(AVOutputFormat *format)
{
    AVOutputFormat **p;
    p = &first_oformat;
Fabrice Bellard's avatar
Fabrice Bellard committed
151 152 153 154 155
    while (*p != NULL) p = &(*p)->next;
    *p = format;
    format->next = NULL;
}

156
int av_match_ext(const char *filename, const char *extensions)
Fabrice Bellard's avatar
Fabrice Bellard committed
157 158 159 160
{
    const char *ext, *p;
    char ext1[32], *q;

Michael Niedermayer's avatar
Michael Niedermayer committed
161 162
    if(!filename)
        return 0;
163

Fabrice Bellard's avatar
Fabrice Bellard committed
164 165 166 167 168 169
    ext = strrchr(filename, '.');
    if (ext) {
        ext++;
        p = extensions;
        for(;;) {
            q = ext1;
170
            while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
Fabrice Bellard's avatar
Fabrice Bellard committed
171 172
                *q++ = *p++;
            *q = '\0';
173
            if (!av_strcasecmp(ext1, ext))
Fabrice Bellard's avatar
Fabrice Bellard committed
174
                return 1;
175
            if (*p == '\0')
Fabrice Bellard's avatar
Fabrice Bellard committed
176 177 178 179 180 181 182
                break;
            p++;
        }
    }
    return 0;
}

183 184 185 186 187 188 189 190 191 192 193
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);
194
        if (!av_strncasecmp(name, names, len))
195 196 197
            return 1;
        names = p+1;
    }
198
    return !av_strcasecmp(name, names);
199 200
}

201 202
AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
                                const char *mime_type)
Fabrice Bellard's avatar
Fabrice Bellard committed
203
{
204
    AVOutputFormat *fmt = NULL, *fmt_found;
Fabrice Bellard's avatar
Fabrice Bellard committed
205 206
    int score_max, score;

207
    /* specific test for image sequences */
208
#if CONFIG_IMAGE2_MUXER
209
    if (!short_name && filename &&
210
        av_filename_number_test(filename) &&
211
        ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
212
        return av_guess_format("image2", NULL, NULL);
213
    }
214
#endif
215
    /* Find the proper file type. */
Fabrice Bellard's avatar
Fabrice Bellard committed
216 217
    fmt_found = NULL;
    score_max = 0;
218
    while ((fmt = av_oformat_next(fmt))) {
Fabrice Bellard's avatar
Fabrice Bellard committed
219 220 221 222 223
        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;
224
        if (filename && fmt->extensions &&
225
            av_match_ext(filename, fmt->extensions)) {
Fabrice Bellard's avatar
Fabrice Bellard committed
226 227 228 229 230 231 232 233
            score += 5;
        }
        if (score > score_max) {
            score_max = score;
            fmt_found = fmt;
        }
    }
    return fmt_found;
234
}
Fabrice Bellard's avatar
Fabrice Bellard committed
235

236
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
237 238
                            const char *filename, const char *mime_type, enum AVMediaType type){
    if(type == AVMEDIA_TYPE_VIDEO){
239 240
        enum CodecID codec_id= CODEC_ID_NONE;

241
#if CONFIG_IMAGE2_MUXER
242
        if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
243
            codec_id= ff_guess_image2_codec(filename);
244
        }
245
#endif
246 247 248
        if(codec_id == CODEC_ID_NONE)
            codec_id= fmt->video_codec;
        return codec_id;
249
    }else if(type == AVMEDIA_TYPE_AUDIO)
250
        return fmt->audio_codec;
251 252
    else if (type == AVMEDIA_TYPE_SUBTITLE)
        return fmt->subtitle_codec;
253 254 255 256
    else
        return CODEC_ID_NONE;
}

257 258
AVInputFormat *av_find_input_format(const char *short_name)
{
259 260
    AVInputFormat *fmt = NULL;
    while ((fmt = av_iformat_next(fmt))) {
261
        if (match_format(short_name, fmt->name))
262 263 264 265 266
            return fmt;
    }
    return NULL;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
267

268
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Michael Niedermayer's avatar
Michael Niedermayer committed
269 270 271 272 273 274
{
    int ret= av_new_packet(pkt, size);

    if(ret<0)
        return ret;

275
    pkt->pos= avio_tell(s);
Michael Niedermayer's avatar
Michael Niedermayer committed
276

277
    ret= avio_read(s, pkt->data, size);
Michael Niedermayer's avatar
Michael Niedermayer committed
278 279 280
    if(ret<=0)
        av_free_packet(pkt);
    else
281
        av_shrink_packet(pkt, ret);
Michael Niedermayer's avatar
Michael Niedermayer committed
282 283 284 285

    return ret;
}

286
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
287 288 289 290 291 292 293 294 295
{
    int ret;
    int old_size;
    if (!pkt->size)
        return av_get_packet(s, pkt, size);
    old_size = pkt->size;
    ret = av_grow_packet(pkt, size);
    if (ret < 0)
        return ret;
296
    ret = avio_read(s, pkt->data + old_size, size);
297 298 299 300
    av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
    return ret;
}

301

302
int av_filename_number_test(const char *filename)
303 304
{
    char buf[1024];
305
    return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
306 307
}

308
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
309
{
310
    AVProbeData lpd = *pd;
311
    AVInputFormat *fmt1 = NULL, *fmt;
312
    int score, id3 = 0;
313

314 315 316 317 318 319
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
        int id3len = ff_id3v2_tag_len(lpd.buf);
        if (lpd.buf_size > id3len + 16) {
            lpd.buf += id3len;
            lpd.buf_size -= id3len;
        }
320
        id3 = 1;
321 322
    }

323
    fmt = NULL;
324
    while ((fmt1 = av_iformat_next(fmt1))) {
325
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
326 327
            continue;
        score = 0;
328
        if (fmt1->read_probe) {
329
            score = fmt1->read_probe(&lpd);
330
        } else if (fmt1->extensions) {
331
            if (av_match_ext(lpd.filename, fmt1->extensions)) {
332 333
                score = 50;
            }
334
        }
335 336
        if (score > *score_max) {
            *score_max = score;
337
            fmt = fmt1;
338 339
        }else if (score == *score_max)
            fmt = NULL;
340
    }
341 342

    /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
343
    if (!fmt && is_opened && *score_max < AVPROBE_SCORE_MAX/4) {
344 345 346 347 348 349 350
        while ((fmt = av_iformat_next(fmt)))
            if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
                *score_max = AVPROBE_SCORE_MAX/4;
                break;
            }
    }

351 352 353 354 355 356 357 358
    if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4-1) {
        while ((fmt = av_iformat_next(fmt)))
            if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
                *score_max = AVPROBE_SCORE_MAX/4-1;
                break;
            }
    }

359 360 361
    return fmt;
}

362 363 364 365 366
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
    int score=0;
    return av_probe_input_format2(pd, is_opened, &score);
}

367
static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
368
{
369 370 371 372 373 374 375 376 377 378 379 380 381 382
    static const struct {
        const char *name; enum CodecID id; enum AVMediaType type;
    } fmt_id_type[] = {
        { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
        { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
        { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
        { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
        { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
        { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
        { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
        { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
        { 0 }
    };
    AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
383 384

    if (fmt) {
385
        int i;
386 387
        av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
               pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
388 389 390 391 392 393
        for (i = 0; fmt_id_type[i].name; i++) {
            if (!strcmp(fmt->name, fmt_id_type[i].name)) {
                st->codec->codec_id   = fmt_id_type[i].id;
                st->codec->codec_type = fmt_id_type[i].type;
                break;
            }
394
        }
395 396 397 398
    }
    return !!fmt;
}

399 400
/************************************************************/
/* input media file */
401

402 403 404 405 406 407
#if FF_API_FORMAT_PARAMETERS
static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
{
    char buf[1024];
    AVDictionary *opts = NULL;

408 409 410
    if (!ap)
        return NULL;

411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
    if (ap->time_base.num) {
        snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
        av_dict_set(&opts, "framerate", buf, 0);
    }
    if (ap->sample_rate) {
        snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
        av_dict_set(&opts, "sample_rate", buf, 0);
    }
    if (ap->channels) {
        snprintf(buf, sizeof(buf), "%d", ap->channels);
        av_dict_set(&opts, "channels", buf, 0);
    }
    if (ap->width || ap->height) {
        snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
        av_dict_set(&opts, "video_size", buf, 0);
    }
    if (ap->pix_fmt != PIX_FMT_NONE) {
        av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
    }
    if (ap->channel) {
        snprintf(buf, sizeof(buf), "%d", ap->channel);
        av_dict_set(&opts, "channel", buf, 0);
    }
    if (ap->standard) {
        av_dict_set(&opts, "standard", ap->standard, 0);
    }
    if (ap->mpeg2ts_compute_pcr) {
        av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
    }
    if (ap->initial_pause) {
        av_dict_set(&opts, "initial_pause", "1", 0);
    }
    return opts;
}

446
/**
447
 * Open a media file from an IO stream. 'fmt' must be specified.
448
 */
449
int av_open_input_stream(AVFormatContext **ic_ptr,
450
                         AVIOContext *pb, const char *filename,
451 452 453
                         AVInputFormat *fmt, AVFormatParameters *ap)
{
    int err;
454
    AVDictionary *opts;
455
    AVFormatContext *ic;
456 457 458 459 460 461
    AVFormatParameters default_ap;

    if(!ap){
        ap=&default_ap;
        memset(ap, 0, sizeof(default_ap));
    }
462
    opts = convert_format_parameters(ap);
463

464
    if(!ap->prealloced_context)
465
        ic = avformat_alloc_context();
466 467
    else
        ic = *ic_ptr;
468
    if (!ic) {
469
        err = AVERROR(ENOMEM);
470 471
        goto fail;
    }
472 473 474 475 476
    if (pb && fmt && fmt->flags & AVFMT_NOFILE)
        av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
                                   "will be ignored with AVFMT_NOFILE format.\n");
    else
        ic->pb = pb;
477

478 479
    if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
        goto fail;
480
    ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
481

482
fail:
483
    *ic_ptr = ic;
484
    av_dict_free(&opts);
485 486
    return err;
}
487
#endif
488

489
/** size of probe buffer, for guessing file type from file contents */
490
#define PROBE_BUF_MIN 2048
491
#define PROBE_BUF_MAX (1<<20)
492

493
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512
                          const char *filename, void *logctx,
                          unsigned int offset, unsigned int max_probe_size)
{
    AVProbeData pd = { filename ? filename : "", NULL, -offset };
    unsigned char *buf = NULL;
    int ret = 0, probe_size;

    if (!max_probe_size) {
        max_probe_size = PROBE_BUF_MAX;
    } else if (max_probe_size > PROBE_BUF_MAX) {
        max_probe_size = PROBE_BUF_MAX;
    } else if (max_probe_size < PROBE_BUF_MIN) {
        return AVERROR(EINVAL);
    }

    if (offset >= max_probe_size) {
        return AVERROR(EINVAL);
    }

513
    for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
514
        probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
515
        int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
516 517 518 519 520 521 522 523
        int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;

        if (probe_size < offset) {
            continue;
        }

        /* read probe data */
        buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
524
        if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
525 526 527 528 529 530
            /* fail if error was not end of file, otherwise, lower score */
            if (ret != AVERROR_EOF) {
                av_free(buf);
                return ret;
            }
            score = 0;
531
            ret = 0;            /* error was end of file, nothing read */
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
        }
        pd.buf_size += ret;
        pd.buf = &buf[offset];

        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);

        /* guess file format */
        *fmt = av_probe_input_format2(&pd, 1, &score);
        if(*fmt){
            if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
                av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
            }else
                av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
        }
    }

548
    if (!*fmt) {
549
        av_free(buf);
550 551 552
        return AVERROR_INVALIDDATA;
    }

553
    /* rewind. reuse probe buffer to avoid seeking */
554
    if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
555
        av_free(buf);
556

557
    return ret;
558 559
}

560
#if FF_API_FORMAT_PARAMETERS
561
int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
562 563 564
                       AVInputFormat *fmt,
                       int buf_size,
                       AVFormatParameters *ap)
Fabrice Bellard's avatar
Fabrice Bellard committed
565
{
566
    int err;
567
    AVDictionary *opts = convert_format_parameters(ap);
Fabrice Bellard's avatar
Fabrice Bellard committed
568

569
    if (!ap || !ap->prealloced_context)
570
        *ic_ptr = NULL;
571

572
    err = avformat_open_input(ic_ptr, filename, fmt, &opts);
573

574
    av_dict_free(&opts);
575
    return err;
Fabrice Bellard's avatar
Fabrice Bellard committed
576
}
577
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
578

579
/* open input file and probe the format if necessary */
580
static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
{
    int ret;
    AVProbeData pd = {filename, NULL, 0};

    if (s->pb) {
        s->flags |= AVFMT_FLAG_CUSTOM_IO;
        if (!s->iformat)
            return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
        else if (s->iformat->flags & AVFMT_NOFILE)
            return AVERROR(EINVAL);
        return 0;
    }

    if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
        (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
        return 0;

598
    if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
599
                          &s->interrupt_callback, options)) < 0)
600
        return ret;
601 602 603 604 605 606 607 608 609
    if (s->iformat)
        return 0;
    return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
}

int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
{
    AVFormatContext *s = *ps;
    int ret = 0;
610
    AVFormatParameters ap = { { 0 } };
611 612 613 614 615 616 617 618 619 620 621 622 623
    AVDictionary *tmp = NULL;

    if (!s && !(s = avformat_alloc_context()))
        return AVERROR(ENOMEM);
    if (fmt)
        s->iformat = fmt;

    if (options)
        av_dict_copy(&tmp, *options, 0);

    if ((ret = av_opt_set_dict(s, &tmp)) < 0)
        goto fail;

624
    if ((ret = init_input(s, filename, &tmp)) < 0)
625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
        goto fail;

    /* check filename in case an image number is expected */
    if (s->iformat->flags & AVFMT_NEEDNUMBER) {
        if (!av_filename_number_test(filename)) {
            ret = AVERROR(EINVAL);
            goto fail;
        }
    }

    s->duration = s->start_time = AV_NOPTS_VALUE;
    av_strlcpy(s->filename, filename, sizeof(s->filename));

    /* allocate private data */
    if (s->iformat->priv_data_size > 0) {
        if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        if (s->iformat->priv_class) {
            *(const AVClass**)s->priv_data = s->iformat->priv_class;
            av_opt_set_defaults(s->priv_data);
            if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
                goto fail;
        }
    }

    /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
    if (s->pb)
        ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);

    if (s->iformat->read_header)
        if ((ret = s->iformat->read_header(s, &ap)) < 0)
            goto fail;

    if (s->pb && !s->data_offset)
        s->data_offset = avio_tell(s->pb);

    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;

    if (options) {
        av_dict_free(options);
        *options = tmp;
    }
    *ps = s;
    return 0;

fail:
    av_dict_free(&tmp);
    if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
        avio_close(s->pb);
    avformat_free_context(s);
    *ps = NULL;
    return ret;
}

681 682
/*******************************************************/

683 684 685
static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
                               AVPacketList **plast_pktl){
    AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
686 687 688
    if (!pktl)
        return NULL;

689 690 691 692 693
    if (*packet_buffer)
        (*plast_pktl)->next = pktl;
    else
        *packet_buffer = pktl;

694 695 696 697 698 699
    /* add the packet in the buffered packet list */
    *plast_pktl = pktl;
    pktl->pkt= *pkt;
    return &pktl->pkt;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
700
int av_read_packet(AVFormatContext *s, AVPacket *pkt)
701
{
702
    int ret, i;
703
    AVStream *st;
704 705 706 707 708 709

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

        if (pktl) {
            *pkt = pktl->pkt;
710
            if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
711 712 713 714 715
               !s->streams[pkt->stream_index]->probe_packets ||
               s->raw_packet_buffer_remaining_size < pkt->size){
                AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
                av_freep(&pd->buf);
                pd->buf_size = 0;
716
                s->raw_packet_buffer = pktl->next;
717
                s->raw_packet_buffer_remaining_size += pkt->size;
718 719 720 721 722
                av_free(pktl);
                return 0;
            }
        }

Michael Niedermayer's avatar
Michael Niedermayer committed
723 724
        av_init_packet(pkt);
        ret= s->iformat->read_packet(s, pkt);
725 726 727 728 729 730 731
        if (ret < 0) {
            if (!pktl || ret == AVERROR(EAGAIN))
                return ret;
            for (i = 0; i < s->nb_streams; i++)
                s->streams[i]->probe_packets = 0;
            continue;
        }
732 733 734 735 736 737

        if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
            (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
            av_log(s, AV_LOG_WARNING,
                   "Dropped corrupted packet (stream = %d)\n",
                   pkt->stream_index);
738
            av_free_packet(pkt);
739 740 741
            continue;
        }

Michael Niedermayer's avatar
Michael Niedermayer committed
742
        st= s->streams[pkt->stream_index];
743

Michael Niedermayer's avatar
Michael Niedermayer committed
744
        switch(st->codec->codec_type){
745
        case AVMEDIA_TYPE_VIDEO:
Michael Niedermayer's avatar
Michael Niedermayer committed
746 747
            if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
            break;
748
        case AVMEDIA_TYPE_AUDIO:
Michael Niedermayer's avatar
Michael Niedermayer committed
749 750
            if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
            break;
751
        case AVMEDIA_TYPE_SUBTITLE:
Michael Niedermayer's avatar
Michael Niedermayer committed
752 753 754
            if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
            break;
        }
755

756 757
        if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
                     !st->probe_packets))
758 759
            return ret;

760
        add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
761
        s->raw_packet_buffer_remaining_size -= pkt->size;
762

763 764
        if(st->codec->codec_id == CODEC_ID_PROBE){
            AVProbeData *pd = &st->probe_data;
765
            av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
766 767
            --st->probe_packets;

768 769 770 771 772
            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);

773
            if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
774
                //FIXME we do not reduce score to 0 for the case of running out of buffer space in bytes
775
                set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
776 777 778
                if(st->codec->codec_id != CODEC_ID_PROBE){
                    pd->buf_size=0;
                    av_freep(&pd->buf);
779
                    av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
Michael Niedermayer's avatar
Michael Niedermayer committed
780
                }
781
            }
782 783
        }
    }
784 785 786 787
}

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

788
/**
789
 * Get the number of samples of an audio frame. Return -1 on error.
790
 */
791 792 793 794
static int get_audio_frame_size(AVCodecContext *enc, int size)
{
    int frame_size;

795 796 797
    if(enc->codec_id == CODEC_ID_VORBIS)
        return -1;

798
    if (enc->frame_size <= 1) {
799 800 801
        int bits_per_sample = av_get_bits_per_sample(enc->codec_id);

        if (bits_per_sample) {
802 803
            if (enc->channels == 0)
                return -1;
804
            frame_size = (size << 3) / (bits_per_sample * enc->channels);
805
        } else {
806 807 808
            /* used for example by ADPCM codecs */
            if (enc->bit_rate == 0)
                return -1;
809
            frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
810 811 812 813 814 815 816 817
        }
    } else {
        frame_size = enc->frame_size;
    }
    return frame_size;
}


818
/**
819
 * Return the frame duration in seconds. Return 0 if not available.
820
 */
821
static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
822 823 824 825 826 827
                                   AVCodecParserContext *pc, AVPacket *pkt)
{
    int frame_size;

    *pnum = 0;
    *pden = 0;
828
    switch(st->codec->codec_type) {
829
    case AVMEDIA_TYPE_VIDEO:
830 831 832 833
        if (st->r_frame_rate.num) {
            *pnum = st->r_frame_rate.den;
            *pden = st->r_frame_rate.num;
        } else if(st->time_base.num*1000LL > st->time_base.den) {
834 835
            *pnum = st->time_base.num;
            *pden = st->time_base.den;
836 837 838
        }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;
839
            if (pc && pc->repeat_pict) {
840
                *pnum = (*pnum) * (1 + pc->repeat_pict);
841
            }
842 843 844 845 846
            //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
            //Thus if we have no parser in such case leave duration undefined.
            if(st->codec->ticks_per_frame>1 && !pc){
                *pnum = *pden = 0;
            }
847 848
        }
        break;
849
    case AVMEDIA_TYPE_AUDIO:
850
        frame_size = get_audio_frame_size(st->codec, pkt->size);
851
        if (frame_size <= 0 || st->codec->sample_rate <= 0)
852 853
            break;
        *pnum = frame_size;
854
        *pden = st->codec->sample_rate;
855 856 857 858 859 860
        break;
    default:
        break;
    }
}

861
static int is_intra_only(AVCodecContext *enc){
862
    if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
863
        return 1;
864
    }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
865 866 867 868
        switch(enc->codec_id){
        case CODEC_ID_MJPEG:
        case CODEC_ID_MJPEGB:
        case CODEC_ID_LJPEG:
869
        case CODEC_ID_PRORES:
870 871 872
        case CODEC_ID_RAWVIDEO:
        case CODEC_ID_DVVIDEO:
        case CODEC_ID_HUFFYUV:
873
        case CODEC_ID_FFVHUFF:
874 875 876
        case CODEC_ID_ASV1:
        case CODEC_ID_ASV2:
        case CODEC_ID_VCR1:
877
        case CODEC_ID_DNXHD:
878
        case CODEC_ID_JPEG2000:
879 880 881 882 883 884 885
            return 1;
        default: break;
        }
    }
    return 0;
}

886 887 888
static void update_initial_timestamps(AVFormatContext *s, int stream_index,
                                      int64_t dts, int64_t pts)
{
889 890 891
    AVStream *st= s->streams[stream_index];
    AVPacketList *pktl= s->packet_buffer;

892
    if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
893 894 895 896 897 898 899 900 901 902 903 904 905 906
        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;
907 908 909

        if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
            st->start_time= pktl->pkt.pts;
910
    }
911 912
    if (st->start_time == AV_NOPTS_VALUE)
        st->start_time = pts;
913 914
}

915 916 917
static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
{
    AVPacketList *pktl= s->packet_buffer;
918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
    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;
933 934 935 936

    for(; pktl; pktl= pktl->next){
        if(pktl->pkt.stream_index != pkt->stream_index)
            continue;
937 938
        if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
           && !pktl->pkt.duration){
939
            pktl->pkt.dts= cur_dts;
940
            if(!st->codec->has_b_frames)
941 942
                pktl->pkt.pts= cur_dts;
            cur_dts += pkt->duration;
943 944 945 946
            pktl->pkt.duration= pkt->duration;
        }else
            break;
    }
947 948
    if(st->first_dts == AV_NOPTS_VALUE)
        st->cur_dts= cur_dts;
949 950
}

951
static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
952 953
                               AVCodecParserContext *pc, AVPacket *pkt)
{
954
    int num, den, presentation_delayed, delay, i;
955
    int64_t offset;
956

957 958 959
    if (s->flags & AVFMT_FLAG_NOFILLIN)
        return;

960 961 962
    if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
        pkt->dts= AV_NOPTS_VALUE;

963
    if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
964
        //FIXME Set low_delay = 0 when has_b_frames = 1
965 966
        st->codec->has_b_frames = 1;

967 968 969
    /* do we have a video B-frame ? */
    delay= st->codec->has_b_frames;
    presentation_delayed = 0;
970

971 972 973
    /* XXX: need has_b_frame, but cannot get it if the codec is
        not initialized */
    if (delay &&
974
        pc && pc->pict_type != AV_PICTURE_TYPE_B)
975 976
        presentation_delayed = 1;

977 978 979 980 981
    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;
    }

982 983 984 985
    // 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){
986
        av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
987 988 989
        pkt->dts= pkt->pts= AV_NOPTS_VALUE;
    }

990
    if (pkt->duration == 0) {
991
        compute_frame_duration(&num, &den, st, pc, pkt);
992
        if (den && num) {
993
            pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
994

995
            if(pkt->duration != 0 && s->packet_buffer)
996
                update_initial_durations(s, st, pkt);
997 998 999
        }
    }

1000 1001
    /* correct timestamps with byte offset if demuxers only have timestamps
       on packet boundaries */
1002 1003 1004 1005 1006 1007 1008 1009 1010
    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;
    }

1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
    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 Biurrun's avatar
Diego Biurrun committed
1030
    /* This may be redundant, but it should not hurt. */
Michael Niedermayer's avatar
Michael Niedermayer committed
1031 1032
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
        presentation_delayed = 1;
1033

1034
//    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);
1035
    /* interpolate PTS and DTS if they are not present */
1036 1037
    //We skip H264 currently because delay and has_b_frames are not reliably set
    if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
Michael Niedermayer's avatar
Michael Niedermayer committed
1038
        if (presentation_delayed) {
1039 1040
            /* DTS = decompression timestamp */
            /* PTS = presentation timestamp */
Michael Niedermayer's avatar
Michael Niedermayer committed
1041
            if (pkt->dts == AV_NOPTS_VALUE)
Michael Niedermayer's avatar
Michael Niedermayer committed
1042
                pkt->dts = st->last_IP_pts;
1043
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
Michael Niedermayer's avatar
Michael Niedermayer committed
1044 1045 1046 1047
            if (pkt->dts == AV_NOPTS_VALUE)
                pkt->dts = st->cur_dts;

            /* this is tricky: the dts must be incremented by the duration
1048
            of the frame we are displaying, i.e. the last I- or P-frame */
Michael Niedermayer's avatar
Michael Niedermayer committed
1049 1050
            if (st->last_IP_duration == 0)
                st->last_IP_duration = pkt->duration;
1051
            if(pkt->dts != AV_NOPTS_VALUE)
Michael Niedermayer's avatar
Michael Niedermayer committed
1052
                st->cur_dts = pkt->dts + st->last_IP_duration;
Michael Niedermayer's avatar
Michael Niedermayer committed
1053 1054
            st->last_IP_duration  = pkt->duration;
            st->last_IP_pts= pkt->pts;
Michael Niedermayer's avatar
Michael Niedermayer committed
1055
            /* cannot compute PTS if not present (we can compute it only
1056
            by knowing the future */
1057
        } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
Michael Niedermayer's avatar
Michael Niedermayer committed
1058 1059 1060 1061 1062 1063 1064
            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);
                }
1065
            }
1066

Michael Niedermayer's avatar
Michael Niedermayer committed
1067 1068 1069
            /* presentation is not delayed : PTS and DTS are the same */
            if(pkt->pts == AV_NOPTS_VALUE)
                pkt->pts = pkt->dts;
1070
            update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
Michael Niedermayer's avatar
Michael Niedermayer committed
1071 1072 1073
            if(pkt->pts == AV_NOPTS_VALUE)
                pkt->pts = st->cur_dts;
            pkt->dts = pkt->pts;
1074
            if(pkt->pts != AV_NOPTS_VALUE)
Michael Niedermayer's avatar
Michael Niedermayer committed
1075
                st->cur_dts = pkt->pts + pkt->duration;
Michael Niedermayer's avatar
Michael Niedermayer committed
1076
        }
1077
    }
1078

1079
    if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1080 1081 1082 1083 1084
        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];
1085
        if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1086
            update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1087
        }
1088 1089 1090 1091 1092
        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);
1093

1094
    /* update flags */
1095
    if(is_intra_only(st->codec))
1096
        pkt->flags |= AV_PKT_FLAG_KEY;
1097
    else if (pc) {
1098
        pkt->flags = 0;
1099
        /* keyframe computation */
1100
        if (pc->key_frame == 1)
1101
            pkt->flags |= AV_PKT_FLAG_KEY;
1102
        else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1103
            pkt->flags |= AV_PKT_FLAG_KEY;
1104
    }
1105 1106
    if (pc)
        pkt->convergence_duration = pc->convergence_duration;
1107 1108 1109
}


1110
static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1111 1112
{
    AVStream *st;
1113
    int len, ret, i;
1114

1115 1116
    av_init_packet(pkt);

1117 1118 1119 1120
    for(;;) {
        /* select current input stream component */
        st = s->cur_st;
        if (st) {
1121
            if (!st->need_parsing || !st->parser) {
1122 1123
                /* no parsing needed: we just output the packet as is */
                /* raw data support */
1124
                *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1125 1126
                compute_pkt_fields(s, st, NULL, pkt);
                s->cur_st = NULL;
1127
                if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1128
                    (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1129 1130 1131
                    ff_reduce_index(s, st->index);
                    av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
                }
1132
                break;
1133
            } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1134 1135 1136 1137
                len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
                                       st->cur_ptr, st->cur_len,
                                       st->cur_pkt.pts, st->cur_pkt.dts,
                                       st->cur_pkt.pos);
1138 1139
                st->cur_pkt.pts = AV_NOPTS_VALUE;
                st->cur_pkt.dts = AV_NOPTS_VALUE;
1140
                /* increment read pointer */
1141 1142
                st->cur_ptr += len;
                st->cur_len -= len;
1143

1144 1145
                /* return packet if any */
                if (pkt->size) {
1146
                got_packet:
1147 1148
                    pkt->duration = 0;
                    pkt->stream_index = st->index;
1149 1150
                    pkt->pts = st->parser->pts;
                    pkt->dts = st->parser->dts;
1151
                    pkt->pos = st->parser->pos;
1152 1153 1154
                    if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
                        s->cur_st = NULL;
                        pkt->destruct= st->cur_pkt.destruct;
1155
                        st->cur_pkt.destruct= NULL;
1156 1157 1158
                        st->cur_pkt.data    = NULL;
                        assert(st->cur_len == 0);
                    }else{
1159
                        pkt->destruct = NULL;
1160
                    }
1161
                    compute_pkt_fields(s, st, st->parser, pkt);
1162

1163
                    if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1164
                        ff_reduce_index(s, st->index);
1165 1166 1167 1168
                        av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
                                           0, 0, AVINDEX_KEYFRAME);
                    }

1169
                    break;
1170 1171
                }
            } else {
Fabrice Bellard's avatar
Fabrice Bellard committed
1172
                /* free packet */
1173
                av_free_packet(&st->cur_pkt);
1174 1175 1176
                s->cur_st = NULL;
            }
        } else {
1177
            AVPacket cur_pkt;
1178
            /* read next packet */
1179
            ret = av_read_packet(s, &cur_pkt);
1180
            if (ret < 0) {
1181
                if (ret == AVERROR(EAGAIN))
1182 1183 1184 1185
                    return ret;
                /* return the last frames, if any */
                for(i = 0; i < s->nb_streams; i++) {
                    st = s->streams[i];
1186
                    if (st->parser && st->need_parsing) {
1187
                        av_parser_parse2(st->parser, st->codec,
1188 1189
                                        &pkt->data, &pkt->size,
                                        NULL, 0,
1190 1191
                                        AV_NOPTS_VALUE, AV_NOPTS_VALUE,
                                        AV_NOPTS_VALUE);
1192 1193 1194 1195
                        if (pkt->size)
                            goto got_packet;
                    }
                }
1196
                /* no more packets: really terminate parsing */
1197
                return ret;
1198
            }
1199 1200
            st = s->streams[cur_pkt.stream_index];
            st->cur_pkt= cur_pkt;
1201

1202 1203 1204
            if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
               st->cur_pkt.dts != AV_NOPTS_VALUE &&
               st->cur_pkt.pts < st->cur_pkt.dts){
1205
                av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1206 1207 1208 1209 1210
                    st->cur_pkt.stream_index,
                    st->cur_pkt.pts,
                    st->cur_pkt.dts,
                    st->cur_pkt.size);
//                av_free_packet(&st->cur_pkt);
1211 1212 1213
//                return -1;
            }

1214
            if(s->debug & FF_FDEBUG_TS)
1215
                av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1216 1217 1218 1219
                    st->cur_pkt.stream_index,
                    st->cur_pkt.pts,
                    st->cur_pkt.dts,
                    st->cur_pkt.size,
1220
                    st->cur_pkt.duration,
1221
                    st->cur_pkt.flags);
1222 1223

            s->cur_st = st;
1224 1225
            st->cur_ptr = st->cur_pkt.data;
            st->cur_len = st->cur_pkt.size;
1226
            if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1227
                st->parser = av_parser_init(st->codec->codec_id);
1228
                if (!st->parser) {
1229
                    /* no parser available: just output the raw packets */
1230 1231
                    st->need_parsing = AVSTREAM_PARSE_NONE;
                }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1232
                    st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1233 1234
                }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
                    st->parser->flags |= PARSER_FLAG_ONCE;
1235 1236 1237 1238
                }
            }
        }
    }
1239
    if(s->debug & FF_FDEBUG_TS)
1240
        av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1241 1242 1243
            pkt->stream_index,
            pkt->pts,
            pkt->dts,
1244
            pkt->size,
1245
            pkt->duration,
1246
            pkt->flags);
1247 1248

    return 0;
1249 1250 1251
}

int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Fabrice Bellard's avatar
Fabrice Bellard committed
1252 1253
{
    AVPacketList *pktl;
1254 1255 1256 1257 1258 1259 1260 1261 1262
    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){
1263
                int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1264
                while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1265
                    if(   pktl->pkt.stream_index == next_pkt->stream_index
1266 1267
                       && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
                       && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1268 1269 1270 1271 1272 1273
                        next_pkt->pts= pktl->pkt.dts;
                    }
                    pktl= pktl->next;
                }
                pktl = s->packet_buffer;
            }
1274 1275 1276

            if(   next_pkt->pts != AV_NOPTS_VALUE
               || next_pkt->dts == AV_NOPTS_VALUE
1277 1278 1279 1280 1281 1282 1283 1284 1285
               || !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){
1286
            int ret= read_frame_internal(s, pkt);
1287
            if(ret<0){
1288
                if(pktl && ret != AVERROR(EAGAIN)){
1289 1290 1291 1292 1293
                    eof=1;
                    continue;
                }else
                    return ret;
            }
1294

1295 1296
            if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
                                           &s->packet_buffer_end)) < 0)
1297
                return AVERROR(ENOMEM);
1298 1299
        }else{
            assert(!s->packet_buffer);
1300
            return read_frame_internal(s, pkt);
1301
        }
1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
    }
}

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

    for(;;) {
        pktl = s->packet_buffer;
1312
        if (!pktl)
1313 1314 1315 1316
            break;
        s->packet_buffer = pktl->next;
        av_free_packet(&pktl->pkt);
        av_free(pktl);
1317
    }
1318 1319 1320 1321 1322 1323
    while(s->raw_packet_buffer){
        pktl = s->raw_packet_buffer;
        s->raw_packet_buffer = pktl->next;
        av_free_packet(&pktl->pkt);
        av_free(pktl);
    }
1324 1325
    s->packet_buffer_end=
    s->raw_packet_buffer_end= NULL;
1326
    s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1327 1328
}

1329 1330 1331
/*******************************************************/
/* seek support */

1332 1333
int av_find_default_stream_index(AVFormatContext *s)
{
1334
    int first_audio_index = -1;
1335 1336 1337 1338 1339 1340 1341
    int i;
    AVStream *st;

    if (s->nb_streams <= 0)
        return -1;
    for(i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
1342
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1343 1344
            return i;
        }
1345
        if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1346
            first_audio_index = i;
1347
    }
1348
    return first_audio_index >= 0 ? first_audio_index : 0;
1349 1350
}

1351 1352 1353
/**
 * Flush the frame reader.
 */
1354
void ff_read_frame_flush(AVFormatContext *s)
1355 1356
{
    AVStream *st;
1357
    int i, j;
1358 1359 1360

    flush_packet_queue(s);

1361
    s->cur_st = NULL;
1362

1363 1364 1365
    /* for each stream, reset read state */
    for(i = 0; i < s->nb_streams; i++) {
        st = s->streams[i];
1366

1367 1368 1369
        if (st->parser) {
            av_parser_close(st->parser);
            st->parser = NULL;
1370
            av_free_packet(&st->cur_pkt);
1371
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1372
        st->last_IP_pts = AV_NOPTS_VALUE;
1373
        st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1374
        st->reference_dts = AV_NOPTS_VALUE;
1375 1376 1377
        /* fail safe */
        st->cur_ptr = NULL;
        st->cur_len = 0;
1378 1379

        st->probe_packets = MAX_PROBE_PACKETS;
1380 1381 1382

        for(j=0; j<MAX_REORDER_DELAY+1; j++)
            st->pts_buffer[j]= AV_NOPTS_VALUE;
1383 1384 1385
    }
}

1386 1387 1388
#if FF_API_SEEK_PUBLIC
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
{
1389
    ff_update_cur_dts(s, ref_st, timestamp);
1390 1391 1392 1393 1394
}
#endif

void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
{
1395 1396 1397
    int i;

    for(i = 0; i < s->nb_streams; i++) {
1398
        AVStream *st = s->streams[i];
1399

1400
        st->cur_dts = av_rescale(timestamp,
1401 1402
                                 st->time_base.den * (int64_t)ref_st->time_base.num,
                                 st->time_base.num * (int64_t)ref_st->time_base.den);
1403 1404 1405
    }
}

1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
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;
    }
}

1419 1420 1421 1422
int ff_add_index_entry(AVIndexEntry **index_entries,
                       int *nb_index_entries,
                       unsigned int *index_entries_allocated_size,
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
1423 1424
{
    AVIndexEntry *entries, *ie;
1425
    int index;
1426

1427
    if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1428
        return -1;
1429

1430 1431 1432
    entries = av_fast_realloc(*index_entries,
                              index_entries_allocated_size,
                              (*nb_index_entries + 1) *
1433
                              sizeof(AVIndexEntry));
1434 1435 1436
    if(!entries)
        return -1;

1437
    *index_entries= entries;
1438

1439
    index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1440

1441
    if(index<0){
1442
        index= (*nb_index_entries)++;
1443
        ie= &entries[index];
1444 1445 1446 1447
        assert(index==0 || ie[-1].timestamp < timestamp);
    }else{
        ie= &entries[index];
        if(ie->timestamp != timestamp){
1448 1449
            if(ie->timestamp <= timestamp)
                return -1;
1450 1451
            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
            (*nb_index_entries)++;
Diego Biurrun's avatar
Diego Biurrun committed
1452
        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1453
            distance= ie->min_distance;
1454
    }
1455

1456 1457
    ie->pos = pos;
    ie->timestamp = timestamp;
1458
    ie->min_distance= distance;
1459
    ie->size= size;
1460
    ie->flags = flags;
1461

1462
    return index;
1463 1464
}

1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
int av_add_index_entry(AVStream *st,
                       int64_t pos, int64_t timestamp, int size, int distance, int flags)
{
    return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
                              &st->index_entries_allocated_size, pos,
                              timestamp, size, distance, flags);
}

int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
                              int64_t wanted_timestamp, int flags)
1475 1476 1477 1478
{
    int a, b, m;
    int64_t timestamp;

1479 1480
    a = - 1;
    b = nb_entries;
1481

1482 1483 1484 1485
    //optimize appending index entries at the end
    if(b && entries[b-1].timestamp < wanted_timestamp)
        a= b-1;

1486 1487
    while (b - a > 1) {
        m = (a + b) >> 1;
1488
        timestamp = entries[m].timestamp;
1489 1490 1491
        if(timestamp >= wanted_timestamp)
            b = m;
        if(timestamp <= wanted_timestamp)
1492
            a = m;
1493
    }
1494
    m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1495

1496 1497 1498 1499 1500
    if(!(flags & AVSEEK_FLAG_ANY)){
        while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
            m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
        }
    }
1501

1502
    if(m == nb_entries)
1503 1504
        return -1;
    return  m;
1505 1506
}

1507 1508 1509 1510 1511 1512 1513
int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
                              int flags)
{
    return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
                                     wanted_timestamp, flags);
}

1514
#if FF_API_SEEK_PUBLIC
1515
int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1516 1517 1518 1519 1520 1521
    return ff_seek_frame_binary(s, stream_index, target_ts, flags);
}
#endif

int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
{
1522
    AVInputFormat *avif= s->iformat;
1523
    int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1524
    int64_t ts_min, ts_max, ts;
1525
    int index;
1526
    int64_t ret;
1527 1528
    AVStream *st;

1529 1530
    if (stream_index < 0)
        return -1;
1531

1532
    av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1533 1534 1535

    ts_max=
    ts_min= AV_NOPTS_VALUE;
Diego Biurrun's avatar
Diego Biurrun committed
1536
    pos_limit= -1; //gcc falsely says it may be uninitialized
1537 1538 1539 1540 1541

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

1542
        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()
1543
        index= FFMAX(index, 0);
1544 1545 1546 1547 1548
        e= &st->index_entries[index];

        if(e->timestamp <= target_ts || e->pos == e->min_distance){
            pos_min= e->pos;
            ts_min= e->timestamp;
1549 1550
            av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
                    pos_min,ts_min);
1551 1552 1553
        }else{
            assert(index==0);
        }
1554 1555

        index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1556 1557
        assert(index < st->nb_index_entries);
        if(index >= 0){
1558 1559 1560 1561 1562
            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;
1563 1564
            av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
                    pos_max,pos_limit, ts_max);
1565 1566 1567
        }
    }

1568
    pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1569 1570 1571 1572
    if(pos<0)
        return -1;

    /* do the seek */
1573
    if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1574
        return ret;
1575

1576
    ff_update_cur_dts(s, st, ts);
1577 1578 1579 1580

    return 0;
}

1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
#if FF_API_SEEK_PUBLIC
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 ))
{
    return ff_gen_search(s, stream_index, target_ts, pos_min, pos_max,
                         pos_limit, ts_min, ts_max, flags, ts_ret,
                         read_timestamp);
}
#endif

int64_t ff_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 ))
{
1598 1599 1600 1601
    int64_t pos, ts;
    int64_t start_pos, filesize;
    int no_change;

1602
    av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1603

1604 1605
    if(ts_min == AV_NOPTS_VALUE){
        pos_min = s->data_offset;
1606
        ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1607 1608 1609 1610 1611 1612
        if (ts_min == AV_NOPTS_VALUE)
            return -1;
    }

    if(ts_max == AV_NOPTS_VALUE){
        int step= 1024;
1613
        filesize = avio_size(s->pb);
1614
        pos_max = filesize - 1;
1615 1616
        do{
            pos_max -= step;
1617
            ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1618 1619 1620 1621
            step += step;
        }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
        if (ts_max == AV_NOPTS_VALUE)
            return -1;
1622

1623 1624
        for(;;){
            int64_t tmp_pos= pos_max + 1;
1625
            int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1626 1627 1628 1629
            if(tmp_ts == AV_NOPTS_VALUE)
                break;
            ts_max= tmp_ts;
            pos_max= tmp_pos;
1630 1631
            if(tmp_pos >= filesize)
                break;
1632 1633 1634 1635
        }
        pos_limit= pos_max;
    }

1636 1637 1638 1639 1640 1641
    if(ts_min > ts_max){
        return -1;
    }else if(ts_min == ts_max){
        pos_limit= pos_min;
    }

1642 1643
    no_change=0;
    while (pos_min < pos_limit) {
1644 1645
        av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
                pos_min, pos_max, ts_min, ts_max);
1646 1647 1648 1649 1650
        assert(pos_limit <= pos_max);

        if(no_change==0){
            int64_t approximate_keyframe_distance= pos_max - pos_limit;
            // interpolate position (better than dichotomy)
1651 1652
            pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
                + pos_min - approximate_keyframe_distance;
1653 1654 1655 1656
        }else if(no_change==1){
            // bisection, if interpolation failed to change min or max pos last time
            pos = (pos_min + pos_limit)>>1;
        }else{
1657 1658
            /* linear search if bisection failed, can only happen if there
               are very few or no keyframes between min/max */
1659 1660 1661 1662 1663 1664 1665 1666
            pos=pos_min;
        }
        if(pos <= pos_min)
            pos= pos_min + 1;
        else if(pos > pos_limit)
            pos= pos_limit;
        start_pos= pos;

1667
        ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1668 1669 1670 1671
        if(pos == pos_max)
            no_change++;
        else
            no_change=0;
1672 1673 1674
        av_dlog(s, "%"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);
1675 1676 1677 1678
        if(ts == AV_NOPTS_VALUE){
            av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
            return -1;
        }
1679
        assert(ts != AV_NOPTS_VALUE);
1680
        if (target_ts <= ts) {
1681 1682 1683
            pos_limit = start_pos - 1;
            pos_max = pos;
            ts_max = ts;
1684 1685
        }
        if (target_ts >= ts) {
1686 1687 1688 1689
            pos_min = pos;
            ts_min = ts;
        }
    }
1690

1691 1692
    pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
    ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1693
    pos_min = pos;
1694
    ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1695
    pos_min++;
1696
    ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1697 1698
    av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
            pos, ts_min, target_ts, ts_max);
1699 1700
    *ts_ret= ts;
    return pos;
1701 1702
}

1703
static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
    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;
1715
    pos_max = avio_size(s->pb) - 1;
1716 1717 1718 1719

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

1720
    avio_seek(s->pb, pos, SEEK_SET);
1721 1722

#if 0
1723
    av_update_cur_dts(s, st, ts);
1724 1725 1726 1727
#endif
    return 0;
}

1728
static int seek_frame_generic(AVFormatContext *s,
1729
                                 int stream_index, int64_t timestamp, int flags)
1730
{
1731 1732
    int index;
    int64_t ret;
1733 1734 1735 1736
    AVStream *st;
    AVIndexEntry *ie;

    st = s->streams[stream_index];
1737

1738
    index = av_index_search_timestamp(st, timestamp, flags);
1739

1740 1741 1742
    if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
        return -1;

1743
    if(index < 0 || index==st->nb_index_entries-1){
1744 1745
        AVPacket pkt;

Michael Niedermayer's avatar
Michael Niedermayer committed
1746 1747
        if(st->nb_index_entries){
            assert(st->index_entries);
1748
            ie= &st->index_entries[st->nb_index_entries-1];
1749
            if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1750
                return ret;
1751
            ff_update_cur_dts(s, st, ie->timestamp);
1752
        }else{
1753
            if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1754 1755
                return ret;
        }
1756
        for (;;) {
1757
            int read_status;
1758
            do{
1759 1760 1761
                read_status = av_read_frame(s, &pkt);
            } while (read_status == AVERROR(EAGAIN));
            if (read_status < 0)
1762 1763 1764
                break;
            av_free_packet(&pkt);
            if(stream_index == pkt.stream_index){
1765
                if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1766 1767 1768 1769 1770
                    break;
            }
        }
        index = av_index_search_timestamp(st, timestamp, flags);
    }
1771 1772 1773
    if (index < 0)
        return -1;

1774
    ff_read_frame_flush(s);
1775 1776 1777 1778 1779
    if (s->iformat->read_seek){
        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
            return 0;
    }
    ie = &st->index_entries[index];
1780
    if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1781
        return ret;
1782
    ff_update_cur_dts(s, st, ie->timestamp);
1783

1784 1785 1786
    return 0;
}

1787
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1788 1789
{
    int ret;
1790
    AVStream *st;
1791

1792
    if (flags & AVSEEK_FLAG_BYTE) {
1793 1794
        if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
            return -1;
1795
        ff_read_frame_flush(s);
1796
        return seek_frame_byte(s, stream_index, timestamp, flags);
1797
    }
1798

1799 1800 1801 1802
    if(stream_index < 0){
        stream_index= av_find_default_stream_index(s);
        if(stream_index < 0)
            return -1;
1803

1804
        st= s->streams[stream_index];
1805
        /* timestamp for default must be expressed in AV_TIME_BASE units */
1806
        timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1807 1808
    }

1809
    /* first, we try the format specific seek */
1810 1811
    if (s->iformat->read_seek) {
        ff_read_frame_flush(s);
1812
        ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1813
    } else
1814 1815 1816 1817
        ret = -1;
    if (ret >= 0) {
        return 0;
    }
1818

1819 1820
    if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
        ff_read_frame_flush(s);
1821
        return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1822 1823
    } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
        ff_read_frame_flush(s);
1824
        return seek_frame_generic(s, stream_index, timestamp, flags);
1825
    }
1826 1827
    else
        return -1;
1828 1829
}

1830 1831 1832 1833 1834
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
{
    if(min_ts > ts || max_ts < ts)
        return -1;

1835 1836
    if (s->iformat->read_seek2) {
        ff_read_frame_flush(s);
1837
        return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1838
    }
1839 1840 1841 1842 1843 1844 1845 1846

    if(s->iformat->read_timestamp){
        //try to seek via read_timestamp()
    }

    //Fallback to old API if new is not implemented but old is
    //Note the old has somewat different sematics
    if(s->iformat->read_seek || 1)
1847
        return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1848

1849
    // try some generic seek like seek_frame_generic() but with new ts semantics
1850 1851
}

1852
/*******************************************************/
1853

1854
/**
1855
 * Return TRUE if the stream has accurate duration in any stream.
1856
 *
1857
 * @return TRUE if the stream has accurate duration for at least one component.
1858
 */
1859
static int has_duration(AVFormatContext *ic)
1860 1861 1862 1863 1864 1865
{
    int i;
    AVStream *st;

    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
1866
        if (st->duration != AV_NOPTS_VALUE)
1867 1868 1869 1870 1871
            return 1;
    }
    return 0;
}

1872 1873 1874 1875 1876
/**
 * Estimate the stream timings from the one of each components.
 *
 * Also computes the global bitrate if possible.
 */
1877
static void update_stream_timings(AVFormatContext *ic)
1878
{
1879
    int64_t start_time, start_time1, end_time, end_time1;
1880
    int64_t duration, duration1, filesize;
1881 1882 1883
    int i;
    AVStream *st;

1884 1885
    start_time = INT64_MAX;
    end_time = INT64_MIN;
1886
    duration = INT64_MIN;
1887 1888
    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
1889
        if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1890
            start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1891
            start_time = FFMIN(start_time, start_time1);
1892
            if (st->duration != AV_NOPTS_VALUE) {
1893 1894
                end_time1 = start_time1
                          + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1895
                end_time = FFMAX(end_time, end_time1);
1896 1897
            }
        }
1898 1899
        if (st->duration != AV_NOPTS_VALUE) {
            duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1900
            duration = FFMAX(duration, duration1);
1901
        }
1902
    }
1903
    if (start_time != INT64_MAX) {
1904
        ic->start_time = start_time;
1905 1906
        if (end_time != INT64_MIN)
            duration = FFMAX(duration, end_time - start_time);
1907 1908 1909
    }
    if (duration != INT64_MIN) {
        ic->duration = duration;
1910
        if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1911
            /* compute the bitrate */
1912
            ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1913
                (double)ic->duration;
1914 1915 1916 1917 1918 1919 1920 1921 1922
        }
    }
}

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

1923
    update_stream_timings(ic);
1924 1925 1926
    for(i = 0;i < ic->nb_streams; i++) {
        st = ic->streams[i];
        if (st->start_time == AV_NOPTS_VALUE) {
1927 1928 1929 1930
            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);
1931 1932 1933 1934
        }
    }
}

1935
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1936 1937 1938 1939 1940 1941
{
    int64_t filesize, duration;
    int bit_rate, i;
    AVStream *st;

    /* if bit_rate is already set, we believe it */
1942
    if (ic->bit_rate <= 0) {
1943 1944 1945
        bit_rate = 0;
        for(i=0;i<ic->nb_streams;i++) {
            st = ic->streams[i];
1946
            if (st->codec->bit_rate > 0)
1947
            bit_rate += st->codec->bit_rate;
1948 1949 1950 1951 1952
        }
        ic->bit_rate = bit_rate;
    }

    /* if duration is already set, we believe it */
1953
    if (ic->duration == AV_NOPTS_VALUE &&
1954 1955
        ic->bit_rate != 0) {
        filesize = ic->pb ? avio_size(ic->pb) : 0;
1956 1957 1958
        if (filesize > 0) {
            for(i = 0; i < ic->nb_streams; i++) {
                st = ic->streams[i];
1959
                duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1960
                if (st->duration == AV_NOPTS_VALUE)
1961 1962 1963 1964 1965 1966 1967
                    st->duration = duration;
            }
        }
    }
}

#define DURATION_MAX_READ_SIZE 250000
1968
#define DURATION_MAX_RETRY 3
1969 1970

/* only usable for MPEG-PS streams */
1971
static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1972 1973 1974 1975
{
    AVPacket pkt1, *pkt = &pkt1;
    AVStream *st;
    int read_size, i, ret;
1976
    int64_t end_time;
1977
    int64_t filesize, offset, duration;
1978
    int retry=0;
1979

1980 1981 1982 1983 1984
    ic->cur_st = NULL;

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

1985
    for (i=0; i<ic->nb_streams; i++) {
1986
        st = ic->streams[i];
1987
        if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1988
            av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1989

1990 1991 1992
        if (st->parser) {
            av_parser_close(st->parser);
            st->parser= NULL;
1993
            av_free_packet(&st->cur_pkt);
1994 1995
        }
    }
1996

1997 1998
    /* estimate the end time (duration) */
    /* XXX: may need to support wrapping */
1999
    filesize = ic->pb ? avio_size(ic->pb) : 0;
2000 2001
    end_time = AV_NOPTS_VALUE;
    do{
2002 2003 2004
        offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
        if (offset < 0)
            offset = 0;
2005

2006 2007 2008 2009 2010
        avio_seek(ic->pb, offset, SEEK_SET);
        read_size = 0;
        for(;;) {
            if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
                break;
2011

2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
            do {
                ret = av_read_packet(ic, pkt);
            } while(ret == AVERROR(EAGAIN));
            if (ret != 0)
                break;
            read_size += pkt->size;
            st = ic->streams[pkt->stream_index];
            if (pkt->pts != AV_NOPTS_VALUE &&
                (st->start_time != AV_NOPTS_VALUE ||
                 st->first_dts  != AV_NOPTS_VALUE)) {
                duration = end_time = pkt->pts;
                if (st->start_time != AV_NOPTS_VALUE)
                    duration -= st->start_time;
                else
                    duration -= st->first_dts;
                if (duration < 0)
                    duration += 1LL<<st->pts_wrap_bits;
                if (duration > 0) {
                    if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
                        st->duration = duration;
                }
2033
            }
2034
            av_free_packet(pkt);
2035
        }
2036 2037 2038
    }while(   end_time==AV_NOPTS_VALUE
           && filesize > (DURATION_MAX_READ_SIZE<<retry)
           && ++retry <= DURATION_MAX_RETRY);
2039

2040
    fill_all_stream_timings(ic);
2041

2042
    avio_seek(ic->pb, old_offset, SEEK_SET);
2043
    for (i=0; i<ic->nb_streams; i++) {
2044 2045
        st= ic->streams[i];
        st->cur_dts= st->first_dts;
Michael Niedermayer's avatar
Michael Niedermayer committed
2046
        st->last_IP_pts = AV_NOPTS_VALUE;
2047
        st->reference_dts = AV_NOPTS_VALUE;
2048
    }
2049 2050
}

2051
static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2052 2053 2054 2055 2056 2057 2058
{
    int64_t file_size;

    /* get the file size, if possible */
    if (ic->iformat->flags & AVFMT_NOFILE) {
        file_size = 0;
    } else {
2059
        file_size = avio_size(ic->pb);
2060
        file_size = FFMAX(0, file_size);
2061 2062
    }

2063 2064
    if ((!strcmp(ic->iformat->name, "mpeg") ||
         !strcmp(ic->iformat->name, "mpegts")) &&
2065
        file_size && ic->pb->seekable) {
2066
        /* get accurate estimate from the PTSes */
2067 2068
        estimate_timings_from_pts(ic, old_offset);
    } else if (has_duration(ic)) {
2069
        /* at least one component has timings - we use them for all
2070 2071 2072
           the components */
        fill_all_stream_timings(ic);
    } else {
2073
        av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2074
        /* less precise: use bitrate info */
2075
        estimate_timings_from_bit_rate(ic);
2076
    }
2077
    update_stream_timings(ic);
2078 2079 2080

    {
        int i;
2081
        AVStream av_unused *st;
2082 2083
        for(i = 0;i < ic->nb_streams; i++) {
            st = ic->streams[i];
2084 2085 2086
            av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
                    (double) st->start_time / AV_TIME_BASE,
                    (double) st->duration   / AV_TIME_BASE);
2087
        }
2088 2089 2090 2091
        av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
                (double) ic->start_time / AV_TIME_BASE,
                (double) ic->duration   / AV_TIME_BASE,
                ic->bit_rate / 1000);
2092 2093 2094
    }
}

2095
static int has_codec_parameters(AVCodecContext *avctx)
2096 2097
{
    int val;
2098
    switch (avctx->codec_type) {
2099
    case AVMEDIA_TYPE_AUDIO:
2100 2101 2102 2103 2104 2105 2106
        val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
        if (!avctx->frame_size &&
            (avctx->codec_id == CODEC_ID_VORBIS ||
             avctx->codec_id == CODEC_ID_AAC ||
             avctx->codec_id == CODEC_ID_MP1 ||
             avctx->codec_id == CODEC_ID_MP2 ||
             avctx->codec_id == CODEC_ID_MP3 ||
2107
             avctx->codec_id == CODEC_ID_CELT))
2108
            return 0;
2109
        break;
2110
    case AVMEDIA_TYPE_VIDEO:
2111
        val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2112 2113 2114 2115 2116
        break;
    default:
        val = 1;
        break;
    }
2117
    return avctx->codec_id != CODEC_ID_NONE && val != 0;
2118 2119
}

2120 2121 2122
static int has_decode_delay_been_guessed(AVStream *st)
{
    return st->codec->codec_id != CODEC_ID_H264 ||
2123
        st->info->nb_decoded_frames >= 6;
2124 2125
}

2126
static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2127 2128
{
    AVCodec *codec;
2129
    int got_picture, ret = 0;
2130
    AVFrame picture;
2131
    AVPacket pkt = *avpkt;
2132

Baptiste Coudurier's avatar
Baptiste Coudurier committed
2133 2134 2135 2136
    if(!st->codec->codec){
        codec = avcodec_find_decoder(st->codec->codec_id);
        if (!codec)
            return -1;
2137
        ret = avcodec_open2(st->codec, codec, options);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2138 2139 2140
        if (ret < 0)
            return ret;
    }
2141

2142 2143 2144 2145 2146 2147
    while (pkt.size > 0 && ret >= 0 &&
           (!has_codec_parameters(st->codec)  ||
           !has_decode_delay_been_guessed(st) ||
           (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
        got_picture = 0;
        avcodec_get_frame_defaults(&picture);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2148
        switch(st->codec->codec_type) {
2149
        case AVMEDIA_TYPE_VIDEO:
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2150
            ret = avcodec_decode_video2(st->codec, &picture,
2151
                                        &got_picture, &pkt);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2152
            break;
2153
        case AVMEDIA_TYPE_AUDIO:
2154
            ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
Baptiste Coudurier's avatar
Baptiste Coudurier committed
2155 2156 2157 2158
            break;
        default:
            break;
        }
2159 2160 2161 2162 2163 2164
        if (ret >= 0) {
            if (got_picture)
                st->info->nb_decoded_frames++;
            pkt.data += ret;
            pkt.size -= ret;
        }
2165 2166 2167 2168
    }
    return ret;
}

2169
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2170 2171 2172 2173 2174 2175 2176 2177 2178
{
    while (tags->id != CODEC_ID_NONE) {
        if (tags->id == id)
            return tags->tag;
        tags++;
    }
    return 0;
}

2179
enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2180
{
2181 2182 2183 2184 2185 2186
    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++) {
2187
        if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2188
            return tags[i].id;
2189 2190 2191 2192
    }
    return CODEC_ID_NONE;
}

2193
unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2194 2195 2196
{
    int i;
    for(i=0; tags && tags[i]; i++){
2197
        int tag= ff_codec_get_tag(tags[i], id);
2198 2199 2200 2201 2202
        if(tag) return tag;
    }
    return 0;
}

2203
enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2204 2205 2206
{
    int i;
    for(i=0; tags && tags[i]; i++){
2207
        enum CodecID id= ff_codec_get_id(tags[i], tag);
2208 2209 2210 2211 2212
        if(id!=CODEC_ID_NONE) return id;
    }
    return CODEC_ID_NONE;
}

2213 2214
static void compute_chapters_end(AVFormatContext *s)
{
2215
    unsigned int i, j;
2216
    int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2217

2218
    for (i = 0; i < s->nb_chapters; i++)
2219
        if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230
            AVChapter *ch = s->chapters[i];
            int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
                                     : INT64_MAX;

            for (j = 0; j < s->nb_chapters; j++) {
                AVChapter *ch1 = s->chapters[j];
                int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
                if (j != i && next_start > ch->start && next_start < end)
                    end = next_start;
            }
            ch->end = (end == INT64_MAX) ? ch->start : end;
2231 2232 2233
        }
}

2234 2235
static int get_std_framerate(int i){
    if(i<60*12) return i*1001;
2236
    else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2237 2238
}

2239 2240 2241 2242
/*
 * Is the time base unreliable.
 * This is a heuristic to balance between quick acceptance of the values in
 * the headers vs. some extra checks.
2243 2244
 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2245 2246 2247 2248 2249
 * 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
2250 2251
/*       || c->codec_tag == AV_RL32("DIVX")
       || c->codec_tag == AV_RL32("XVID")*/
2252 2253 2254
       || c->codec_id == CODEC_ID_MPEG2VIDEO
       || c->codec_id == CODEC_ID_H264
       )
2255 2256 2257 2258
        return 1;
    return 0;
}

2259
#if FF_API_FORMAT_PARAMETERS
2260
int av_find_stream_info(AVFormatContext *ic)
2261 2262 2263 2264 2265 2266
{
    return avformat_find_stream_info(ic, NULL);
}
#endif

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2267
{
2268
    int i, count, ret, read_size, j;
2269
    AVStream *st;
2270
    AVPacket pkt1, *pkt;
2271
    int64_t old_offset = avio_tell(ic->pb);
2272
    int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2273

2274
    for(i=0;i<ic->nb_streams;i++) {
2275
        AVCodec *codec;
2276
        st = ic->streams[i];
2277

2278 2279
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
            st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2280 2281
/*            if(!st->time_base.num)
                st->time_base= */
2282 2283
            if(!st->codec->time_base.num)
                st->codec->time_base= st->time_base;
2284
        }
2285
        //only for the split stuff
2286
        if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2287
            st->parser = av_parser_init(st->codec->codec_id);
2288
            if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2289 2290
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
            }
2291
        }
2292
        assert(!st->codec->codec);
2293 2294
        codec = avcodec_find_decoder(st->codec->codec_id);

2295 2296 2297 2298 2299
        /* this function doesn't flush the decoders, so force thread count
         * to 1 to fix behavior when thread count > number of frames in the file */
        if (options)
            av_dict_set(&options[i], "threads", "1", 0);

2300 2301 2302
        /* Ensure that subtitle_header is properly set. */
        if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
            && codec && !st->codec->codec)
2303
            avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2304

2305 2306
        //try to just open decoders, in case this is enough to get parameters
        if(!has_codec_parameters(st->codec)){
2307
            if (codec && !st->codec->codec)
2308
                avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2309
        }
2310 2311
    }

2312
    for (i=0; i<ic->nb_streams; i++) {
2313
        ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2314
    }
2315

2316 2317 2318
    count = 0;
    read_size = 0;
    for(;;) {
2319
        if (ff_check_interrupt(&ic->interrupt_callback)){
2320
            ret= AVERROR_EXIT;
2321
            av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2322 2323 2324
            break;
        }

2325 2326
        /* check if one codec still needs to be handled */
        for(i=0;i<ic->nb_streams;i++) {
2327 2328
            int fps_analyze_framecount = 20;

2329
            st = ic->streams[i];
2330
            if (!has_codec_parameters(st->codec))
2331
                break;
2332 2333 2334 2335 2336
            /* if the timebase is coarse (like the usual millisecond precision
               of mkv), we need to analyze more frames to reliably arrive at
               the correct fps */
            if (av_q2d(st->time_base) > 0.0005)
                fps_analyze_framecount *= 2;
2337 2338
            if (ic->fps_probe_size >= 0)
                fps_analyze_framecount = ic->fps_probe_size;
2339
            /* variable fps and no guess at the real fps */
2340
            if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2341 2342
               && st->info->duration_count < fps_analyze_framecount
               && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2343
                break;
2344
            if(st->parser && st->parser->parser->split && !st->codec->extradata)
2345
                break;
2346 2347
            if(st->first_dts == AV_NOPTS_VALUE)
                break;
2348 2349 2350 2351 2352
        }
        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 */
2353
            if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2354 2355
                /* if we found the info for all the codecs, we can stop */
                ret = count;
2356
                av_log(ic, AV_LOG_DEBUG, "All info found\n");
2357 2358
                break;
            }
2359
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
2360
        /* we did not get all the codec info, but we read too much data */
2361
        if (read_size >= ic->probesize) {
Michael Niedermayer's avatar
Michael Niedermayer committed
2362
            ret = count;
2363
            av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
Michael Niedermayer's avatar
Michael Niedermayer committed
2364 2365
            break;
        }
2366

2367 2368
        /* NOTE: a new stream can be added there if no header in file
           (AVFMTCTX_NOHEADER) */
2369
        ret = read_frame_internal(ic, &pkt1);
2370 2371 2372 2373
        if (ret == AVERROR(EAGAIN))
            continue;

        if (ret < 0) {
2374 2375
            /* EOF or error */
            ret = -1; /* we could not have all the codec parameters before EOF */
2376 2377
            for(i=0;i<ic->nb_streams;i++) {
                st = ic->streams[i];
2378 2379 2380
                if (!has_codec_parameters(st->codec)){
                    char buf[256];
                    avcodec_string(buf, sizeof(buf), st->codec, 0);
2381
                    av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2382 2383
                } else {
                    ret = 0;
2384
                }
2385
            }
2386 2387 2388
            break;
        }

2389
        pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2390 2391
        if ((ret = av_dup_packet(pkt)) < 0)
            goto find_stream_info_err;
2392

2393
        read_size += pkt->size;
2394 2395

        st = ic->streams[pkt->stream_index];
2396 2397
        if (st->codec_info_nb_frames>1) {
            if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2398
                av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2399
                break;
2400
            }
2401
            st->info->codec_info_duration += pkt->duration;
2402
        }
2403
        {
2404
            int64_t last = st->info->last_dts;
2405

2406 2407
            if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
                int64_t duration= pkt->dts - last;
2408 2409
                double dur= duration * av_q2d(st->time_base);

2410
//                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2411
//                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2412 2413 2414
                if (st->info->duration_count < 2)
                    memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
                for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
2415 2416
                    int framerate= get_std_framerate(i);
                    int ticks= lrintf(dur*framerate/(1001*12));
2417
                    double error = dur - (double)ticks*1001*12 / framerate;
2418
                    st->info->duration_error[i] += error*error;
Michael Niedermayer's avatar
Michael Niedermayer committed
2419
                }
2420
                st->info->duration_count++;
2421
                // ignore the first 4 values, they might have some random jitter
2422 2423
                if (st->info->duration_count > 3)
                    st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2424
            }
2425 2426
            if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
                st->info->last_dts = pkt->dts;
2427
        }
2428 2429
        if(st->parser && st->parser->parser->split && !st->codec->extradata){
            int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2430
            if(i){
2431
                st->codec->extradata_size= i;
2432
                st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2433
                memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2434
                memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2435 2436
            }
        }
2437

2438 2439
        /* if still no information, we try to open the codec and to
           decompress the frame. We try to avoid that in most cases as
2440
           it takes longer and uses more memory. For MPEG-4, we need to
2441 2442 2443 2444 2445 2446
           decompress for QuickTime.

           If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
           least one frame of codec data, this makes sure the codec initializes
           the channel configuration and does not only trust the values from the container.
        */
2447
        try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2448

2449
        st->codec_info_nb_frames++;
2450 2451 2452
        count++;
    }

Diego Biurrun's avatar
Diego Biurrun committed
2453
    // close codecs which were opened in try_decode_frame()
2454 2455
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2456 2457
        if(st->codec->codec)
            avcodec_close(st->codec);
2458
    }
2459 2460
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2461
        if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2462
            av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2463
                     (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2464
                      st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2465
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2466 2467 2468
            // the check for tb_unreliable() is not completely correct, since this is not about handling
            // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
            // ipmovie.c produces.
2469 2470 2471
            if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
                av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
            if (st->info->duration_count && !st->r_frame_rate.num
2472
               && tb_unreliable(st->codec) /*&&
2473
               //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2474
               st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2475
                int num = 0;
2476
                double best_error= 2*av_q2d(st->time_base);
2477
                best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2478

2479 2480
                for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
                    double error = st->info->duration_error[j] * get_std_framerate(j);
2481
//                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2482
//                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2483 2484
                    if(error < best_error){
                        best_error= error;
2485
                        num = get_std_framerate(j);
2486
                    }
2487
                }
2488 2489 2490
                // do not increase frame rate by more than 1 % in order to match a standard rate.
                if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
                    av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2491 2492
            }

2493
            if (!st->r_frame_rate.num){
2494
                if(    st->codec->time_base.den * (int64_t)st->time_base.num
2495
                    <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2496
                    st->r_frame_rate.num = st->codec->time_base.den;
2497
                    st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2498 2499 2500 2501
                }else{
                    st->r_frame_rate.num = st->time_base.den;
                    st->r_frame_rate.den = st->time_base.num;
                }
2502
            }
2503
        }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2504 2505
            if(!st->codec->bits_per_coded_sample)
                st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
            // set stream disposition based on audio service type
            switch (st->codec->audio_service_type) {
            case AV_AUDIO_SERVICE_TYPE_EFFECTS:
                st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
            case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
                st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
            case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
                st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
            case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
                st->disposition = AV_DISPOSITION_COMMENT;          break;
            case AV_AUDIO_SERVICE_TYPE_KARAOKE:
                st->disposition = AV_DISPOSITION_KARAOKE;          break;
            }
2519
        }
Fabrice Bellard's avatar
Fabrice Bellard committed
2520
    }
2521

2522
    estimate_timings(ic, old_offset);
John Donaghy's avatar
John Donaghy committed
2523

2524 2525
    compute_chapters_end(ic);

2526
#if 0
2527
    /* correct DTS for B-frame streams with no timestamps */
2528 2529
    for(i=0;i<ic->nb_streams;i++) {
        st = ic->streams[i];
2530
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549
            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
2550

2551 2552 2553
 find_stream_info_err:
    for (i=0; i < ic->nb_streams; i++)
        av_freep(&ic->streams[i]->info);
2554
    return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
2555 2556
}

2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
{
    int i, j;

    for (i = 0; i < ic->nb_programs; i++)
        for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
            if (ic->programs[i]->stream_index[j] == s)
                return ic->programs[i];
    return NULL;
}

int av_find_best_stream(AVFormatContext *ic,
                        enum AVMediaType type,
                        int wanted_stream_nb,
                        int related_stream,
                        AVCodec **decoder_ret,
                        int flags)
{
2575
    int i, nb_streams = ic->nb_streams;
2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587
    int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
    unsigned *program = NULL;
    AVCodec *decoder = NULL, *best_decoder = NULL;

    if (related_stream >= 0 && wanted_stream_nb < 0) {
        AVProgram *p = find_program_from_stream(ic, related_stream);
        if (p) {
            program = p->stream_index;
            nb_streams = p->nb_stream_indexes;
        }
    }
    for (i = 0; i < nb_streams; i++) {
2588 2589
        int real_stream_index = program ? program[i] : i;
        AVStream *st = ic->streams[real_stream_index];
2590 2591 2592
        AVCodecContext *avctx = st->codec;
        if (avctx->codec_type != type)
            continue;
2593
        if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2594
            continue;
2595 2596
        if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
            continue;
2597
        if (decoder_ret) {
2598
            decoder = avcodec_find_decoder(st->codec->codec_id);
2599 2600 2601 2602 2603 2604 2605 2606 2607
            if (!decoder) {
                if (ret < 0)
                    ret = AVERROR_DECODER_NOT_FOUND;
                continue;
            }
        }
        if (best_count >= st->codec_info_nb_frames)
            continue;
        best_count = st->codec_info_nb_frames;
2608
        ret = real_stream_index;
2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620
        best_decoder = decoder;
        if (program && i == nb_streams - 1 && ret < 0) {
            program = NULL;
            nb_streams = ic->nb_streams;
            i = 0; /* no related stream found, try again with everything */
        }
    }
    if (decoder_ret)
        *decoder_ret = best_decoder;
    return ret;
}

2621 2622 2623 2624
/*******************************************************/

int av_read_play(AVFormatContext *s)
{
2625 2626
    if (s->iformat->read_play)
        return s->iformat->read_play(s);
2627
    if (s->pb)
2628
        return avio_pause(s->pb, 0);
2629
    return AVERROR(ENOSYS);
2630 2631 2632 2633
}

int av_read_pause(AVFormatContext *s)
{
2634 2635
    if (s->iformat->read_pause)
        return s->iformat->read_pause(s);
2636
    if (s->pb)
2637
        return avio_pause(s->pb, 1);
2638
    return AVERROR(ENOSYS);
2639 2640
}

2641
#if FF_API_FORMAT_PARAMETERS
2642
void av_close_input_stream(AVFormatContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
2643
{
2644
    flush_packet_queue(s);
2645 2646
    if (s->iformat->read_close)
        s->iformat->read_close(s);
2647 2648
    avformat_free_context(s);
}
2649
#endif
2650 2651 2652 2653 2654 2655

void avformat_free_context(AVFormatContext *s)
{
    int i;
    AVStream *st;

2656
    av_opt_free(s);
2657
    if (s->iformat && s->iformat->priv_class && s->priv_data)
2658 2659
        av_opt_free(s->priv_data);

Fabrice Bellard's avatar
Fabrice Bellard committed
2660
    for(i=0;i<s->nb_streams;i++) {
2661 2662
        /* free all data in a stream component */
        st = s->streams[i];
2663 2664
        if (st->parser) {
            av_parser_close(st->parser);
2665
            av_free_packet(&st->cur_pkt);
Fabrice Bellard's avatar
Fabrice Bellard committed
2666
        }
2667
        av_dict_free(&st->metadata);
2668
        av_free(st->index_entries);
2669
        av_free(st->codec->extradata);
2670
        av_free(st->codec->subtitle_header);
2671
        av_free(st->codec);
2672
        av_free(st->priv_data);
2673
        av_free(st->info);
2674
        av_free(st);
Fabrice Bellard's avatar
Fabrice Bellard committed
2675
    }
2676
    for(i=s->nb_programs-1; i>=0; i--) {
2677
        av_dict_free(&s->programs[i]->metadata);
2678
        av_freep(&s->programs[i]->stream_index);
2679 2680
        av_freep(&s->programs[i]);
    }
Michael Niedermayer's avatar
Michael Niedermayer committed
2681
    av_freep(&s->programs);
2682
    av_freep(&s->priv_data);
2683
    while(s->nb_chapters--) {
2684
        av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2685
        av_free(s->chapters[s->nb_chapters]);
2686 2687
    }
    av_freep(&s->chapters);
2688
    av_dict_free(&s->metadata);
2689
    av_freep(&s->streams);
2690
    av_free(s);
Fabrice Bellard's avatar
Fabrice Bellard committed
2691 2692
}

2693
#if FF_API_CLOSE_INPUT_FILE
2694 2695
void av_close_input_file(AVFormatContext *s)
{
2696 2697 2698 2699 2700 2701 2702
    avformat_close_input(&s);
}
#endif

void avformat_close_input(AVFormatContext **ps)
{
    AVFormatContext *s = *ps;
2703 2704
    AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
                       NULL : s->pb;
2705 2706 2707 2708
    flush_packet_queue(s);
    if (s->iformat->read_close)
        s->iformat->read_close(s);
    avformat_free_context(s);
2709
    *ps = NULL;
2710
    if (pb)
2711
        avio_close(pb);
2712 2713
}

2714
#if FF_API_NEW_STREAM
2715
AVStream *av_new_stream(AVFormatContext *s, int id)
2716 2717 2718 2719 2720 2721 2722 2723 2724
{
    AVStream *st = avformat_new_stream(s, NULL);
    if (st)
        st->id = id;
    return st;
}
#endif

AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2725 2726
{
    AVStream *st;
2727
    int i;
2728
    AVStream **streams;
2729

2730 2731 2732 2733 2734 2735
    if (s->nb_streams >= INT_MAX/sizeof(*streams))
        return NULL;
    streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
    if (!streams)
        return NULL;
    s->streams = streams;
2736 2737 2738 2739

    st = av_mallocz(sizeof(AVStream));
    if (!st)
        return NULL;
2740 2741 2742 2743
    if (!(st->info = av_mallocz(sizeof(*st->info)))) {
        av_free(st);
        return NULL;
    }
2744

2745
    st->codec = avcodec_alloc_context3(c);
2746 2747
    if (s->iformat) {
        /* no default bitrate if decoding */
2748
        st->codec->bit_rate = 0;
2749
    }
2750
    st->index = s->nb_streams;
2751 2752
    st->start_time = AV_NOPTS_VALUE;
    st->duration = AV_NOPTS_VALUE;
2753 2754 2755 2756 2757
        /* 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;
2758
    st->first_dts = AV_NOPTS_VALUE;
2759
    st->probe_packets = MAX_PROBE_PACKETS;
2760

2761
    /* default pts setting is MPEG-like */
2762
    avpriv_set_pts_info(st, 33, 1, 90000);
Michael Niedermayer's avatar
Michael Niedermayer committed
2763
    st->last_IP_pts = AV_NOPTS_VALUE;
2764 2765
    for(i=0; i<MAX_REORDER_DELAY+1; i++)
        st->pts_buffer[i]= AV_NOPTS_VALUE;
2766
    st->reference_dts = AV_NOPTS_VALUE;
2767

2768 2769
    st->sample_aspect_ratio = (AVRational){0,1};

2770 2771 2772 2773
    s->streams[s->nb_streams++] = st;
    return st;
}

2774 2775 2776 2777 2778
AVProgram *av_new_program(AVFormatContext *ac, int id)
{
    AVProgram *program=NULL;
    int i;

2779
    av_dlog(ac, "new_program: id=0x%04x\n", id);
2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796

    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;
}

2797
AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2798
{
2799 2800 2801
    AVChapter *chapter = NULL;
    int i;

2802
    for(i=0; i<s->nb_chapters; i++)
2803 2804 2805 2806 2807
        if(s->chapters[i]->id == id)
            chapter = s->chapters[i];

    if(!chapter){
        chapter= av_mallocz(sizeof(AVChapter));
Michael Niedermayer's avatar
Michael Niedermayer committed
2808
        if(!chapter)
2809
            return NULL;
2810
        dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2811
    }
2812
    av_dict_set(&chapter->metadata, "title", title, 0);
2813
    chapter->id    = id;
2814
    chapter->time_base= time_base;
2815
    chapter->start = start;
Michael Niedermayer's avatar
Michael Niedermayer committed
2816
    chapter->end   = end;
2817

2818
    return chapter;
2819
}
2820

2821 2822
/************************************************************/
/* output media file */
Fabrice Bellard's avatar
Fabrice Bellard committed
2823

2824
#if FF_API_FORMAT_PARAMETERS
2825 2826 2827
int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
{
    int ret;
2828

2829 2830 2831
    if (s->oformat->priv_data_size > 0) {
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
        if (!s->priv_data)
2832
            return AVERROR(ENOMEM);
2833 2834 2835 2836
        if (s->oformat->priv_class) {
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
            av_opt_set_defaults(s->priv_data);
        }
2837 2838
    } else
        s->priv_data = NULL;
2839

2840 2841 2842 2843 2844 2845 2846
    if (s->oformat->set_parameters) {
        ret = s->oformat->set_parameters(s, ap);
        if (ret < 0)
            return ret;
    }
    return 0;
}
2847
#endif
2848

2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864
static int validate_codec_tag(AVFormatContext *s, AVStream *st)
{
    const AVCodecTag *avctag;
    int n;
    enum CodecID id = CODEC_ID_NONE;
    unsigned int tag = 0;

    /**
     * Check that tag + id is in the table
     * If neither is in the table -> OK
     * If tag is in the table with another id -> FAIL
     * If id is in the table with another tag -> FAIL unless strict < normal
     */
    for (n = 0; s->oformat->codec_tag[n]; n++) {
        avctag = s->oformat->codec_tag[n];
        while (avctag->id != CODEC_ID_NONE) {
2865
            if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881
                id = avctag->id;
                if (id == st->codec->codec_id)
                    return 1;
            }
            if (avctag->id == st->codec->codec_id)
                tag = avctag->tag;
            avctag++;
        }
    }
    if (id != CODEC_ID_NONE)
        return 0;
    if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
        return 0;
    return 1;
}

2882
#if FF_API_FORMAT_PARAMETERS
2883 2884
int av_write_header(AVFormatContext *s)
{
2885 2886 2887 2888 2889 2890 2891
    return avformat_write_header(s, NULL);
}
#endif

int avformat_write_header(AVFormatContext *s, AVDictionary **options)
{
    int ret = 0, i;
2892
    AVStream *st;
2893 2894 2895 2896 2897 2898
    AVDictionary *tmp = NULL;

    if (options)
        av_dict_copy(&tmp, *options, 0);
    if ((ret = av_opt_set_dict(s, &tmp)) < 0)
        goto fail;
2899

2900
    // some sanity checks
2901
    if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2902
        av_log(s, AV_LOG_ERROR, "no streams\n");
2903 2904
        ret = AVERROR(EINVAL);
        goto fail;
2905 2906
    }

2907 2908 2909 2910
    for(i=0;i<s->nb_streams;i++) {
        st = s->streams[i];

        switch (st->codec->codec_type) {
2911
        case AVMEDIA_TYPE_AUDIO:
2912 2913
            if(st->codec->sample_rate<=0){
                av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2914 2915
                ret = AVERROR(EINVAL);
                goto fail;
2916
            }
2917 2918 2919
            if(!st->codec->block_align)
                st->codec->block_align = st->codec->channels *
                    av_get_bits_per_sample(st->codec->codec_id) >> 3;
2920
            break;
2921
        case AVMEDIA_TYPE_VIDEO:
2922 2923
            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");
2924 2925
                ret = AVERROR(EINVAL);
                goto fail;
2926
            }
2927
            if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2928
                av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2929 2930
                ret = AVERROR(EINVAL);
                goto fail;
2931
            }
2932 2933
            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");
2934 2935
                ret = AVERROR(EINVAL);
                goto fail;
2936
            }
2937 2938
            break;
        }
2939 2940

        if(s->oformat->codec_tag){
2941 2942 2943 2944
            if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
                //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
                st->codec->codec_tag= 0;
            }
2945
            if(st->codec->codec_tag){
2946
                if (!validate_codec_tag(s, st)) {
2947 2948
                    char tagbuf[32];
                    av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2949
                    av_log(s, AV_LOG_ERROR,
2950 2951
                           "Tag %s/0x%08x incompatible with output codec id '%d'\n",
                           tagbuf, st->codec->codec_tag, st->codec->codec_id);
2952 2953
                    ret = AVERROR_INVALIDDATA;
                    goto fail;
2954
                }
2955 2956 2957
            }else
                st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
        }
2958 2959 2960 2961

        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);
2962 2963
    }

2964
    if (!s->priv_data && s->oformat->priv_data_size > 0) {
2965
        s->priv_data = av_mallocz(s->oformat->priv_data_size);
2966 2967 2968 2969 2970 2971 2972 2973 2974 2975
        if (!s->priv_data) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        if (s->oformat->priv_class) {
            *(const AVClass**)s->priv_data= s->oformat->priv_class;
            av_opt_set_defaults(s->priv_data);
            if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
                goto fail;
        }
2976
    }
2977

2978
    /* set muxer identification string */
2979
    if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2980
        av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2981 2982
    }

2983 2984 2985
    if(s->oformat->write_header){
        ret = s->oformat->write_header(s);
        if (ret < 0)
2986
            goto fail;
2987
    }
2988 2989 2990

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

2994
        switch (st->codec->codec_type) {
2995
        case AVMEDIA_TYPE_AUDIO:
2996
            den = (int64_t)st->time_base.num * st->codec->sample_rate;
2997
            break;
2998
        case AVMEDIA_TYPE_VIDEO:
2999
            den = (int64_t)st->time_base.num * st->codec->time_base.den;
3000 3001 3002 3003
            break;
        default:
            break;
        }
3004
        if (den != AV_NOPTS_VALUE) {
3005 3006 3007 3008
            if (den <= 0) {
                ret = AVERROR_INVALIDDATA;
                goto fail;
            }
3009
            frac_init(&st->pts, 0, 0, den);
3010
        }
3011
    }
3012 3013 3014 3015 3016

    if (options) {
        av_dict_free(options);
        *options = tmp;
    }
3017
    return 0;
3018 3019 3020
fail:
    av_dict_free(&tmp);
    return ret;
3021 3022
}

3023
//FIXME merge with compute_pkt_fields
3024
static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3025 3026
    int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
    int num, den, frame_size, i;
3027

3028
    av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3029
            pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3030

3031
/*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3032
        return AVERROR(EINVAL);*/
3033

3034
    /* duration field */
3035 3036 3037
    if (pkt->duration == 0) {
        compute_frame_duration(&num, &den, st, NULL, pkt);
        if (den && num) {
3038
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3039 3040
        }
    }
3041

3042 3043 3044
    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
        pkt->pts= pkt->dts;

3045
    //XXX/FIXME this is a temporary hack until all encoders output pts
3046
    if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3047 3048 3049 3050 3051
        pkt->dts=
//        pkt->pts= st->cur_dts;
        pkt->pts= st->pts.val;
    }

3052
    //calculate dts from pts
3053
    if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3054 3055
        st->pts_buffer[0]= pkt->pts;
        for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3056
            st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3057
        for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3058
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3059 3060

        pkt->dts= st->pts_buffer[0];
3061
    }
3062

3063
    if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
3064
        av_log(s, AV_LOG_ERROR,
3065
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3066
               st->index, st->cur_dts, pkt->dts);
3067
        return AVERROR(EINVAL);
3068 3069
    }
    if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3070
        av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3071
        return AVERROR(EINVAL);
3072 3073
    }

3074
//    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3075 3076 3077
    st->cur_dts= pkt->dts;
    st->pts.val= pkt->dts;

3078
    /* update pts */
3079
    switch (st->codec->codec_type) {
3080
    case AVMEDIA_TYPE_AUDIO:
3081
        frame_size = get_audio_frame_size(st->codec, pkt->size);
3082

3083 3084 3085
        /* 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 */
3086
        if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3087
            frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3088
        }
3089
        break;
3090
    case AVMEDIA_TYPE_VIDEO:
3091
        frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3092 3093 3094 3095
        break;
    default:
        break;
    }
3096
    return 0;
3097 3098 3099 3100
}

int av_write_frame(AVFormatContext *s, AVPacket *pkt)
{
3101
    int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3102

3103
    if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3104
        return ret;
3105

3106
    ret= s->oformat->write_packet(s, pkt);
3107 3108 3109

    if (ret >= 0)
        s->streams[pkt->stream_index]->nb_frames++;
3110
    return ret;
3111 3112
}

3113 3114 3115 3116 3117 3118 3119
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;
3120 3121
    pkt->destruct= NULL;             // do not free original but only the copy
    av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3122

3123 3124 3125
    if(s->streams[pkt->stream_index]->last_in_packet_buffer){
        next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
    }else
3126
        next_point = &s->packet_buffer;
3127 3128 3129 3130

    if(*next_point){
        if(compare(s, &s->packet_buffer_end->pkt, pkt)){
            while(!compare(s, &(*next_point)->pkt, pkt)){
3131 3132
                next_point= &(*next_point)->next;
            }
3133
            goto next_non_null;
3134 3135
        }else{
            next_point = &(s->packet_buffer_end->next);
3136
        }
3137
    }
3138
    assert(!*next_point);
3139

3140
    s->packet_buffer_end= this_pktl;
3141
next_non_null:
3142

3143
    this_pktl->next= *next_point;
3144

3145 3146
    s->streams[pkt->stream_index]->last_in_packet_buffer=
    *next_point= this_pktl;
3147 3148
}

3149
static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3150 3151 3152
{
    AVStream *st = s->streams[ pkt ->stream_index];
    AVStream *st2= s->streams[ next->stream_index];
3153 3154 3155 3156
    int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
                             st->time_base);

    if (comp == 0)
3157
        return pkt->stream_index < next->stream_index;
3158
    return comp > 0;
3159 3160
}

3161
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3162
    AVPacketList *pktl;
3163
    int stream_count=0;
3164
    int i;
3165 3166

    if(pkt){
3167
        ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3168
    }
3169

3170
    for(i=0; i < s->nb_streams; i++)
3171
        stream_count+= !!s->streams[i]->last_in_packet_buffer;
3172

3173
    if(stream_count && (s->nb_streams == stream_count || flush)){
3174 3175
        pktl= s->packet_buffer;
        *out= pktl->pkt;
3176 3177

        s->packet_buffer= pktl->next;
3178 3179 3180
        if(!s->packet_buffer)
            s->packet_buffer_end= NULL;

3181 3182
        if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
            s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3183 3184 3185 3186 3187 3188 3189 3190 3191
        av_freep(&pktl);
        return 1;
    }else{
        av_init_packet(out);
        return 0;
    }
}

/**
3192
 * Interleave an AVPacket correctly so it can be muxed.
3193 3194 3195 3196
 * @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
3197
 * @return 1 if a packet was output, 0 if no packet could be output,
3198
 *         < 0 if an error occurred
3199
 */
3200
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3201 3202 3203 3204 3205 3206
    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);
}

3207 3208
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
    AVStream *st= s->streams[ pkt->stream_index];
3209
    int ret;
3210

3211
    //FIXME/XXX/HACK drop zero sized packets
3212
    if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3213
        return 0;
3214

3215 3216
    av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
            pkt->size, pkt->dts, pkt->pts);
3217 3218
    if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
        return ret;
3219

3220
    if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3221
        return AVERROR(EINVAL);
3222

3223 3224
    for(;;){
        AVPacket opkt;
3225
        int ret= interleave_packet(s, &opkt, pkt, 0);
3226 3227
        if(ret<=0) //FIXME cleanup needed for ret<0 ?
            return ret;
3228

3229
        ret= s->oformat->write_packet(s, &opkt);
3230 3231
        if (ret >= 0)
            s->streams[opkt.stream_index]->nb_frames++;
3232

3233 3234
        av_free_packet(&opkt);
        pkt= NULL;
3235

3236 3237 3238
        if(ret<0)
            return ret;
    }
3239 3240 3241 3242
}

int av_write_trailer(AVFormatContext *s)
{
3243
    int ret, i;
3244

3245 3246
    for(;;){
        AVPacket pkt;
3247
        ret= interleave_packet(s, &pkt, NULL, 1);
3248
        if(ret<0) //FIXME cleanup needed for ret<0 ?
3249
            goto fail;
3250 3251
        if(!ret)
            break;
3252

3253
        ret= s->oformat->write_packet(s, &pkt);
3254 3255
        if (ret >= 0)
            s->streams[pkt.stream_index]->nb_frames++;
3256

3257
        av_free_packet(&pkt);
3258

3259
        if(ret<0)
3260
            goto fail;
3261 3262
    }

3263 3264
    if(s->oformat->write_trailer)
        ret = s->oformat->write_trailer(s);
3265
fail:
3266
    for(i=0;i<s->nb_streams;i++) {
3267
        av_freep(&s->streams[i]->priv_data);
3268 3269
        av_freep(&s->streams[i]->index_entries);
    }
3270
    if (s->oformat->priv_class)
3271
        av_opt_free(s->priv_data);
3272 3273
    av_freep(&s->priv_data);
    return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
3274 3275
}

3276
void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3277 3278 3279 3280 3281
{
    int i, j;
    AVProgram *program=NULL;
    void *tmp;

3282 3283 3284 3285 3286
    if (idx >= ac->nb_streams) {
        av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
        return;
    }

3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303
    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;
    }
}

3304 3305 3306 3307 3308 3309 3310
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);
}

3311
static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3312
{
3313 3314
    if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
        AVDictionaryEntry *tag=NULL;
3315 3316

        av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3317
        while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3318
            if(strcmp("language", tag->key))
Michael Niedermayer's avatar
Michael Niedermayer committed
3319
                av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3320 3321 3322 3323
        }
    }
}

Fabrice Bellard's avatar
Fabrice Bellard committed
3324
/* "user interface" functions */
3325
static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3326
{
3327
    char buf[256];
3328 3329
    int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
    AVStream *st = ic->streams[i];
3330
    int g = av_gcd(st->time_base.num, st->time_base.den);
3331
    AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3332 3333 3334 3335 3336 3337
    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);
3338 3339
    if (lang)
        av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3340
    av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3341
    av_log(NULL, AV_LOG_INFO, ": %s", buf);
3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352
    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);
    }
3353
    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3354 3355
        if(st->avg_frame_rate.den && st->avg_frame_rate.num)
            print_fps(av_q2d(st->avg_frame_rate), "fps");
3356
        if(st->r_frame_rate.den && st->r_frame_rate.num)
3357
            print_fps(av_q2d(st->r_frame_rate), "tbr");
3358
        if(st->time_base.den && st->time_base.num)
3359
            print_fps(1/av_q2d(st->time_base), "tbn");
3360
        if(st->codec->time_base.den && st->codec->time_base.num)
3361
            print_fps(1/av_q2d(st->codec->time_base), "tbc");
3362
    }
3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380
    if (st->disposition & AV_DISPOSITION_DEFAULT)
        av_log(NULL, AV_LOG_INFO, " (default)");
    if (st->disposition & AV_DISPOSITION_DUB)
        av_log(NULL, AV_LOG_INFO, " (dub)");
    if (st->disposition & AV_DISPOSITION_ORIGINAL)
        av_log(NULL, AV_LOG_INFO, " (original)");
    if (st->disposition & AV_DISPOSITION_COMMENT)
        av_log(NULL, AV_LOG_INFO, " (comment)");
    if (st->disposition & AV_DISPOSITION_LYRICS)
        av_log(NULL, AV_LOG_INFO, " (lyrics)");
    if (st->disposition & AV_DISPOSITION_KARAOKE)
        av_log(NULL, AV_LOG_INFO, " (karaoke)");
    if (st->disposition & AV_DISPOSITION_FORCED)
        av_log(NULL, AV_LOG_INFO, " (forced)");
    if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
        av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
    if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
        av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3381 3382
    if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
        av_log(NULL, AV_LOG_INFO, " (clean effects)");
3383
    av_log(NULL, AV_LOG_INFO, "\n");
3384
    dump_metadata(NULL, st->metadata, "    ");
3385
}
Fabrice Bellard's avatar
Fabrice Bellard committed
3386

3387
#if FF_API_DUMP_FORMAT
Fabrice Bellard's avatar
Fabrice Bellard committed
3388
void dump_format(AVFormatContext *ic,
3389
                 int index,
Fabrice Bellard's avatar
Fabrice Bellard committed
3390 3391
                 const char *url,
                 int is_output)
3392 3393 3394 3395 3396 3397 3398 3399 3400
{
    av_dump_format(ic, index, url, is_output);
}
#endif

void av_dump_format(AVFormatContext *ic,
                    int index,
                    const char *url,
                    int is_output)
Fabrice Bellard's avatar
Fabrice Bellard committed
3401
{
3402
    int i;
3403
    uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3404 3405
    if (ic->nb_streams && !printed)
        return;
Fabrice Bellard's avatar
Fabrice Bellard committed
3406

3407
    av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
Fabrice Bellard's avatar
Fabrice Bellard committed
3408
            is_output ? "Output" : "Input",
3409 3410
            index,
            is_output ? ic->oformat->name : ic->iformat->name,
Fabrice Bellard's avatar
Fabrice Bellard committed
3411
            is_output ? "to" : "from", url);
3412
    dump_metadata(NULL, ic->metadata, "  ");
3413
    if (!is_output) {
3414
        av_log(NULL, AV_LOG_INFO, "  Duration: ");
3415 3416 3417 3418 3419 3420 3421 3422
        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;
3423 3424
            av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
                   (100 * us) / AV_TIME_BASE);
3425
        } else {
3426
            av_log(NULL, AV_LOG_INFO, "N/A");
3427
        }
3428 3429
        if (ic->start_time != AV_NOPTS_VALUE) {
            int secs, us;
3430
            av_log(NULL, AV_LOG_INFO, ", start: ");
3431
            secs = ic->start_time / AV_TIME_BASE;
3432
            us = abs(ic->start_time % AV_TIME_BASE);
3433
            av_log(NULL, AV_LOG_INFO, "%d.%06d",
3434 3435
                   secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
        }
3436
        av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3437
        if (ic->bit_rate) {
3438
            av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3439
        } else {
3440
            av_log(NULL, AV_LOG_INFO, "N/A");
3441
        }
3442
        av_log(NULL, AV_LOG_INFO, "\n");
3443
    }
3444 3445 3446 3447 3448 3449 3450 3451
    for (i = 0; i < ic->nb_chapters; i++) {
        AVChapter *ch = ic->chapters[i];
        av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
        av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
        av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));

        dump_metadata(NULL, ch->metadata, "    ");
    }
3452
    if(ic->nb_programs) {
3453
        int j, k, total = 0;
3454
        for(j=0; j<ic->nb_programs; j++) {
3455
            AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3456
                                                  "name", NULL, 0);
3457
            av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3458
                   name ? name->value : "");
3459
            dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3460
            for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3461
                dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3462 3463 3464 3465 3466 3467 3468
                printed[ic->programs[j]->stream_index[k]] = 1;
            }
            total += ic->programs[j]->nb_stream_indexes;
        }
        if (total < ic->nb_streams)
            av_log(NULL, AV_LOG_INFO, "  No Program\n");
    }
3469 3470
    for(i=0;i<ic->nb_streams;i++)
        if (!printed[i])
3471
            dump_stream_format(ic, i, index, is_output);
3472 3473

    av_free(printed);
Fabrice Bellard's avatar
Fabrice Bellard committed
3474 3475
}

3476 3477 3478 3479 3480 3481 3482
int64_t av_gettime(void)
{
    struct timeval tv;
    gettimeofday(&tv,NULL);
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
}

3483 3484 3485 3486 3487
uint64_t ff_ntp_time(void)
{
  return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
}

3488 3489
#if FF_API_PARSE_DATE
#include "libavutil/parseutils.h"
3490

3491 3492 3493 3494 3495
int64_t parse_date(const char *timestr, int duration)
{
    int64_t timeval;
    av_parse_time(&timeval, timestr, duration);
    return timeval;
Fabrice Bellard's avatar
Fabrice Bellard committed
3496
}
3497
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3498

3499 3500 3501
#if FF_API_FIND_INFO_TAG
#include "libavutil/parseutils.h"

Fabrice Bellard's avatar
Fabrice Bellard committed
3502 3503
int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
{
3504
    return av_find_info_tag(arg, arg_size, tag1, info);
Fabrice Bellard's avatar
Fabrice Bellard committed
3505
}
3506
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
3507

3508 3509
int av_get_frame_filename(char *buf, int buf_size,
                          const char *path, int number)
3510 3511
{
    const char *p;
3512 3513
    char *q, buf1[20], c;
    int nd, len, percentd_found;
3514 3515 3516 3517 3518 3519 3520 3521 3522

    q = buf;
    p = path;
    percentd_found = 0;
    for(;;) {
        c = *p++;
        if (c == '\0')
            break;
        if (c == '%') {
3523 3524 3525 3526 3527 3528 3529 3530
            do {
                nd = 0;
                while (isdigit(*p)) {
                    nd = nd * 10 + *p++ - '0';
                }
                c = *p++;
            } while (isdigit(c));

3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562
            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;
}

3563
static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3564 3565
{
    int len, i, j, c;
3566
#undef fprintf
3567
#define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3568 3569 3570 3571 3572

    for(i=0;i<size;i+=16) {
        len = size - i;
        if (len > 16)
            len = 16;
3573
        PRINT("%08x ", i);
3574 3575
        for(j=0;j<16;j++) {
            if (j < len)
3576
                PRINT(" %02x", buf[i+j]);
3577
            else
3578
                PRINT("   ");
3579
        }
3580
        PRINT(" ");
3581 3582 3583 3584
        for(j=0;j<len;j++) {
            c = buf[i+j];
            if (c < ' ' || c > '~')
                c = '.';
3585
            PRINT("%c", c);
3586
        }
3587
        PRINT("\n");
3588
    }
3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599
#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);
3600 3601
}

3602
static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3603
{
3604
#undef fprintf
3605 3606
#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);
3607
    PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3608
    PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3609
    /* DTS is _always_ valid after av_read_frame() */
3610
    PRINT("  dts=");
3611
    if (pkt->dts == AV_NOPTS_VALUE)
3612
        PRINT("N/A");
3613
    else
3614
        PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3615
    /* PTS may not be known if B-frames are present. */
3616
    PRINT("  pts=");
3617
    if (pkt->pts == AV_NOPTS_VALUE)
3618
        PRINT("N/A");
3619
    else
3620
        PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3621 3622 3623
    PRINT("\n");
    PRINT("  size=%d\n", pkt->size);
#undef PRINT
3624 3625 3626 3627
    if (dump_payload)
        av_hex_dump(f, pkt->data, pkt->size);
}

3628
#if FF_API_PKT_DUMP
3629 3630
void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
{
3631 3632 3633
    AVRational tb = { 1, AV_TIME_BASE };
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
}
3634
#endif
3635 3636 3637 3638

void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
{
    pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3639 3640
}

3641
#if FF_API_PKT_DUMP
3642 3643
void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
{
3644 3645 3646
    AVRational tb = { 1, AV_TIME_BASE };
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
}
3647
#endif
3648 3649 3650 3651 3652

void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
                      AVStream *st)
{
    pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3653 3654
}

3655 3656 3657 3658 3659 3660
void av_url_split(char *proto, int proto_size,
                  char *authorization, int authorization_size,
                  char *hostname, int hostname_size,
                  int *port_ptr,
                  char *path, int path_size,
                  const char *url)
Fabrice Bellard's avatar
Fabrice Bellard committed
3661
{
3662
    const char *p, *ls, *at, *col, *brk;
3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675

    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++;
Fabrice Bellard's avatar
Fabrice Bellard committed
3676
    } else {
3677 3678 3679 3680
        /* no protocol means plain filename */
        av_strlcpy(path, url, path_size);
        return;
    }
3681

3682
    /* separate path from hostname */
3683 3684 3685 3686
    ls = strchr(p, '/');
    if(!ls)
        ls = strchr(p, '?');
    if(ls)
Michael Niedermayer's avatar
Michael Niedermayer committed
3687
        av_strlcpy(path, ls, path_size);
3688
    else
3689 3690 3691 3692 3693 3694 3695 3696 3697
        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 '@' */
Fabrice Bellard's avatar
Fabrice Bellard committed
3698
        }
3699

3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712
        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));
Fabrice Bellard's avatar
Fabrice Bellard committed
3713 3714 3715
    }
}

3716
char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3717 3718
{
    int i;
3719
    static const char hex_table_uc[16] = { '0', '1', '2', '3',
Martin Storsjö's avatar
Martin Storsjö committed
3720 3721 3722
                                           '4', '5', '6', '7',
                                           '8', '9', 'A', 'B',
                                           'C', 'D', 'E', 'F' };
3723 3724 3725 3726 3727
    static const char hex_table_lc[16] = { '0', '1', '2', '3',
                                           '4', '5', '6', '7',
                                           '8', '9', 'a', 'b',
                                           'c', 'd', 'e', 'f' };
    const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3728 3729

    for(i = 0; i < s; i++) {
3730 3731
        buff[i * 2]     = hex_table[src[i] >> 4];
        buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3732 3733 3734 3735 3736
    }

    return buff;
}

3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764
int ff_hex_to_data(uint8_t *data, const char *p)
{
    int c, len, v;

    len = 0;
    v = 1;
    for (;;) {
        p += strspn(p, SPACE_CHARS);
        if (*p == '\0')
            break;
        c = toupper((unsigned char) *p++);
        if (c >= '0' && c <= '9')
            c = c - '0';
        else if (c >= 'A' && c <= 'F')
            c = c - 'A' + 10;
        else
            break;
        v = (v << 4) | c;
        if (v & 0x100) {
            if (data)
                data[len] = v;
            len++;
            v = 1;
        }
    }
    return len;
}

3765
#if FF_API_SET_PTS_INFO
3766
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3767
                     unsigned int pts_num, unsigned int pts_den)
3768 3769 3770 3771 3772 3773 3774
{
    avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
}
#endif

void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
                         unsigned int pts_num, unsigned int pts_den)
Fabrice Bellard's avatar
Fabrice Bellard committed
3775
{
3776 3777 3778 3779
    AVRational new_tb;
    if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
        if(new_tb.num != pts_num)
            av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3780 3781
    }else
        av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3782

3783 3784 3785 3786 3787 3788
    if(new_tb.num <= 0 || new_tb.den <= 0) {
        av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
        return;
    }
    s->time_base = new_tb;
    s->pts_wrap_bits = pts_wrap_bits;
Fabrice Bellard's avatar
Fabrice Bellard committed
3789
}
3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801

int ff_url_join(char *str, int size, const char *proto,
                const char *authorization, const char *hostname,
                int port, const char *fmt, ...)
{
#if CONFIG_NETWORK
    struct addrinfo hints, *ai;
#endif

    str[0] = '\0';
    if (proto)
        av_strlcatf(str, size, "%s://", proto);
3802
    if (authorization && authorization[0])
3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834
        av_strlcatf(str, size, "%s@", authorization);
#if CONFIG_NETWORK && defined(AF_INET6)
    /* Determine if hostname is a numerical IPv6 address,
     * properly escape it within [] in that case. */
    memset(&hints, 0, sizeof(hints));
    hints.ai_flags = AI_NUMERICHOST;
    if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
        if (ai->ai_family == AF_INET6) {
            av_strlcat(str, "[", size);
            av_strlcat(str, hostname, size);
            av_strlcat(str, "]", size);
        } else {
            av_strlcat(str, hostname, size);
        }
        freeaddrinfo(ai);
    } else
#endif
        /* Not an IPv6 address, just output the plain string. */
        av_strlcat(str, hostname, size);

    if (port >= 0)
        av_strlcatf(str, size, ":%d", port);
    if (fmt) {
        va_list vl;
        int len = strlen(str);

        va_start(vl, fmt);
        vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
        va_end(vl);
    }
    return strlen(str);
}
3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853

int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
                     AVFormatContext *src)
{
    AVPacket local_pkt;

    local_pkt = *pkt;
    local_pkt.stream_index = dst_stream;
    if (pkt->pts != AV_NOPTS_VALUE)
        local_pkt.pts = av_rescale_q(pkt->pts,
                                     src->streams[pkt->stream_index]->time_base,
                                     dst->streams[dst_stream]->time_base);
    if (pkt->dts != AV_NOPTS_VALUE)
        local_pkt.dts = av_rescale_q(pkt->dts,
                                     src->streams[pkt->stream_index]->time_base,
                                     dst->streams[dst_stream]->time_base);
    return av_write_frame(dst, &local_pkt);
}

3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
                        void *context)
{
    const char *ptr = str;

    /* Parse key=value pairs. */
    for (;;) {
        const char *key;
        char *dest = NULL, *dest_end;
        int key_len, dest_len = 0;

        /* Skip whitespace and potential commas. */
        while (*ptr && (isspace(*ptr) || *ptr == ','))
            ptr++;
        if (!*ptr)
            break;

        key = ptr;

        if (!(ptr = strchr(key, '=')))
            break;
        ptr++;
        key_len = ptr - key;

        callback_get_buf(context, key, key_len, &dest, &dest_len);
        dest_end = dest + dest_len - 1;

        if (*ptr == '\"') {
            ptr++;
            while (*ptr && *ptr != '\"') {
                if (*ptr == '\\') {
                    if (!ptr[1])
                        break;
                    if (dest && dest < dest_end)
                        *dest++ = ptr[1];
                    ptr += 2;
                } else {
                    if (dest && dest < dest_end)
                        *dest++ = *ptr;
                    ptr++;
                }
            }
            if (*ptr == '\"')
                ptr++;
        } else {
            for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
                if (dest && dest < dest_end)
                    *dest++ = *ptr;
        }
        if (dest)
            *dest = 0;
    }
}

Peter Ross's avatar
Peter Ross committed
3908 3909 3910 3911 3912 3913 3914 3915 3916
int ff_find_stream_index(AVFormatContext *s, int id)
{
    int i;
    for (i = 0; i < s->nb_streams; i++) {
        if (s->streams[i]->id == id)
            return i;
    }
    return -1;
}
3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967

void ff_make_absolute_url(char *buf, int size, const char *base,
                          const char *rel)
{
    char *sep;
    /* Absolute path, relative to the current server */
    if (base && strstr(base, "://") && rel[0] == '/') {
        if (base != buf)
            av_strlcpy(buf, base, size);
        sep = strstr(buf, "://");
        if (sep) {
            sep += 3;
            sep = strchr(sep, '/');
            if (sep)
                *sep = '\0';
        }
        av_strlcat(buf, rel, size);
        return;
    }
    /* If rel actually is an absolute url, just copy it */
    if (!base || strstr(rel, "://") || rel[0] == '/') {
        av_strlcpy(buf, rel, size);
        return;
    }
    if (base != buf)
        av_strlcpy(buf, base, size);
    /* Remove the file name from the base url */
    sep = strrchr(buf, '/');
    if (sep)
        sep[1] = '\0';
    else
        buf[0] = '\0';
    while (av_strstart(rel, "../", NULL) && sep) {
        /* Remove the path delimiter at the end */
        sep[0] = '\0';
        sep = strrchr(buf, '/');
        /* If the next directory name to pop off is "..", break here */
        if (!strcmp(sep ? &sep[1] : buf, "..")) {
            /* Readd the slash we just removed */
            av_strlcat(buf, "/", size);
            break;
        }
        /* Cut off the directory name */
        if (sep)
            sep[1] = '\0';
        else
            buf[0] = '\0';
        rel += 3;
    }
    av_strlcat(buf, rel, size);
}
3968 3969 3970

int64_t ff_iso8601_to_unix_time(const char *datestr)
{
3971
#if HAVE_STRPTIME
3972 3973 3974 3975 3976 3977 3978 3979
    struct tm time1 = {0}, time2 = {0};
    char *ret1, *ret2;
    ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
    ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
    if (ret2 && !ret1)
        return av_timegm(&time2);
    else
        return av_timegm(&time1);
3980 3981 3982 3983 3984
#else
    av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
                                 "the date string.\n");
    return 0;
#endif
3985
}
3986 3987 3988 3989 3990 3991 3992 3993 3994 3995

int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
{
    if (ofmt) {
        if (ofmt->query_codec)
            return ofmt->query_codec(codec_id, std_compliance);
        else if (ofmt->codec_tag)
            return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
        else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
                 codec_id == ofmt->subtitle_codec)
3996
            return 1;
3997 3998 3999
    }
    return AVERROR_PATCHWELCOME;
}
4000 4001 4002 4003 4004

int avformat_network_init(void)
{
#if CONFIG_NETWORK
    int ret;
4005
    ff_network_inited_globally = 1;
4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020
    if ((ret = ff_network_init()) < 0)
        return ret;
    ff_tls_init();
#endif
    return 0;
}

int avformat_network_deinit(void)
{
#if CONFIG_NETWORK
    ff_network_close();
    ff_tls_deinit();
#endif
    return 0;
}
4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062

int ff_add_param_change(AVPacket *pkt, int32_t channels,
                        uint64_t channel_layout, int32_t sample_rate,
                        int32_t width, int32_t height)
{
    uint32_t flags = 0;
    int size = 4;
    uint8_t *data;
    if (!pkt)
        return AVERROR(EINVAL);
    if (channels) {
        size += 4;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
    }
    if (channel_layout) {
        size += 8;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
    }
    if (sample_rate) {
        size += 4;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
    }
    if (width || height) {
        size += 8;
        flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
    }
    data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
    if (!data)
        return AVERROR(ENOMEM);
    bytestream_put_le32(&data, flags);
    if (channels)
        bytestream_put_le32(&data, channels);
    if (channel_layout)
        bytestream_put_le64(&data, channel_layout);
    if (sample_rate)
        bytestream_put_le32(&data, sample_rate);
    if (width || height) {
        bytestream_put_le32(&data, width);
        bytestream_put_le32(&data, height);
    }
    return 0;
}