git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

   1 /*
   2  * various utility functions for use within FFmpeg
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdint.h>
  23
  24 #include "avformat.h"
  25 #include "avio_internal.h"
  26 #include "internal.h"
  27 #include "libavcodec/internal.h"
  28 #include "libavcodec/raw.h"
  29 #include "libavcodec/bytestream.h"
  30 #include "libavutil/opt.h"
  31 #include "libavutil/dict.h"
  32 #include "libavutil/internal.h"
  33 #include "libavutil/pixdesc.h"
  34 #include "metadata.h"
  35 #include "id3v2.h"
  36 #include "libavutil/avassert.h"
  37 #include "libavutil/avstring.h"
  38 #include "libavutil/mathematics.h"
  39 #include "libavutil/parseutils.h"
  40 #include "libavutil/time.h"
  41 #include "libavutil/timestamp.h"
  42 #include "riff.h"
  43 #include "audiointerleave.h"
  44 #include "url.h"
  45 #include <stdarg.h>
  46 #if CONFIG_NETWORK
  47 #include "network.h"
  48 #endif
  49
  50 #undef NDEBUG
  51 #include <assert.h>
  52
  53 /**
  54  * @file
  55  * various utility functions for use within FFmpeg
  56  */
  57
  58 unsigned avformat_version(void)
  59 {
  60     av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
  61     return LIBAVFORMAT_VERSION_INT;
  62 }
  63
  64 const char *avformat_configuration(void)
  65 {
  66     return FFMPEG_CONFIGURATION;
  67 }
  68
  69 const char *avformat_license(void)
  70 {
  71 #define LICENSE_PREFIX "libavformat license: "
  72     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  73 }
  74
  75 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
  76
  77 static int is_relative(int64_t ts) {
  78     return ts > (RELATIVE_TS_BASE - (1LL<<48));
  79 }
  80
  81 /**
  82  * Wrap a given time stamp, if there is an indication for an overflow
  83  *
  84  * @param st stream
  85  * @param timestamp the time stamp to wrap
  86  * @return resulting time stamp
  87  */
  88 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
  89 {
  90     if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
  91         st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
  92         if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
  93             timestamp < st->pts_wrap_reference)
  94             return timestamp + (1ULL<<st->pts_wrap_bits);
  95         else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
  96             timestamp >= st->pts_wrap_reference)
  97             return timestamp - (1ULL<<st->pts_wrap_bits);
  98     }
  99     return timestamp;
 100 }
 101
 102 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
 103 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
 104 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
 105 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
 106
 107 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
 108 {
 109     if (st->codec->codec)
 110         return st->codec->codec;
 111
 112     switch(st->codec->codec_type){
 113     case AVMEDIA_TYPE_VIDEO:
 114         if(s->video_codec)    return s->video_codec;
 115         break;
 116     case AVMEDIA_TYPE_AUDIO:
 117         if(s->audio_codec)    return s->audio_codec;
 118         break;
 119     case AVMEDIA_TYPE_SUBTITLE:
 120         if(s->subtitle_codec) return s->subtitle_codec;
 121         break;
 122     }
 123
 124     return avcodec_find_decoder(codec_id);
 125 }
 126
 127 int av_format_get_probe_score(const AVFormatContext *s)
 128 {
 129     return s->probe_score;
 130 }
 131
 132 /* an arbitrarily chosen "sane" max packet size -- 50M */
 133 #define SANE_CHUNK_SIZE (50000000)
 134
 135 int ffio_limit(AVIOContext *s, int size)
 136 {
 137     if(s->maxsize>=0){
 138         int64_t remaining= s->maxsize - avio_tell(s);
 139         if(remaining < size){
 140             int64_t newsize= avio_size(s);
 141             if(!s->maxsize || s->maxsize<newsize)
 142                 s->maxsize= newsize - !newsize;
 143             remaining= s->maxsize - avio_tell(s);
 144             remaining= FFMAX(remaining, 0);
 145         }
 146
 147         if(s->maxsize>=0 && remaining+1 < size){
 148             av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
 149             size= remaining+1;
 150         }
 151     }
 152     return size;
 153 }
 154
 155 /*
 156  * Read the data in sane-sized chunks and append to pkt.
 157  * Return the number of bytes read or an error.
 158  */
 159 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
 160 {
 161     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
 162     int orig_size      = pkt->size;
 163     int ret;
 164
 165     do {
 166         int prev_size = pkt->size;
 167         int read_size;
 168
 169         /*
 170          * When the caller requests a lot of data, limit it to the amount left
 171          * in file or SANE_CHUNK_SIZE when it is not known
 172          */
 173         read_size = size;
 174         if (read_size > SANE_CHUNK_SIZE/10) {
 175             read_size = ffio_limit(s, read_size);
 176             // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
 177             if (s->maxsize < 0)
 178                 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
 179         }
 180
 181         ret = av_grow_packet(pkt, read_size);
 182         if (ret < 0)
 183             break;
 184
 185         ret = avio_read(s, pkt->data + prev_size, read_size);
 186         if (ret != read_size) {
 187             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
 188             break;
 189         }
 190
 191         size -= read_size;
 192     } while (size > 0);
 193     if (size > 0)
 194         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 195
 196     pkt->pos = orig_pos;
 197     if (!pkt->size)
 198         av_free_packet(pkt);
 199     return pkt->size > orig_size ? pkt->size - orig_size : ret;
 200 }
 201
 202 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 203 {
 204     av_init_packet(pkt);
 205     pkt->data = NULL;
 206     pkt->size = 0;
 207     pkt->pos  = avio_tell(s);
 208
 209     return append_packet_chunked(s, pkt, size);
 210 }
 211
 212 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 213 {
 214     if (!pkt->size)
 215         return av_get_packet(s, pkt, size);
 216     return append_packet_chunked(s, pkt, size);
 217 }
 218
 219
 220 int av_filename_number_test(const char *filename)
 221 {
 222     char buf[1024];
 223     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
 224 }
 225
 226 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
 227 {
 228     AVProbeData lpd = *pd;
 229     AVInputFormat *fmt1 = NULL, *fmt;
 230     int score, nodat = 0, score_max=0;
 231     const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
 232
 233     if (!lpd.buf)
 234         lpd.buf = zerobuffer;
 235
 236     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
 237         int id3len = ff_id3v2_tag_len(lpd.buf);
 238         if (lpd.buf_size > id3len + 16) {
 239             lpd.buf += id3len;
 240             lpd.buf_size -= id3len;
 241         }else
 242             nodat = 1;
 243     }
 244
 245     fmt = NULL;
 246     while ((fmt1 = av_iformat_next(fmt1))) {
 247         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
 248             continue;
 249         score = 0;
 250         if (fmt1->read_probe) {
 251             score = fmt1->read_probe(&lpd);
 252             if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
 253                 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
 254         } else if (fmt1->extensions) {
 255             if (av_match_ext(lpd.filename, fmt1->extensions)) {
 256                 score = AVPROBE_SCORE_EXTENSION;
 257             }
 258         }
 259         if (score > score_max) {
 260             score_max = score;
 261             fmt = fmt1;
 262         }else if (score == score_max)
 263             fmt = NULL;
 264     }
 265     if(nodat)
 266         score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
 267     *score_ret= score_max;
 268
 269     return fmt;
 270 }
 271
 272 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
 273 {
 274     int score_ret;
 275     AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
 276     if(score_ret > *score_max){
 277         *score_max= score_ret;
 278         return fmt;
 279     }else
 280         return NULL;
 281 }
 282
 283 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
 284     int score=0;
 285     return av_probe_input_format2(pd, is_opened, &score);
 286 }
 287
 288 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
 289 {
 290     static const struct {
 291         const char *name; enum AVCodecID id; enum AVMediaType type;
 292     } fmt_id_type[] = {
 293         { "aac"      , AV_CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
 294         { "ac3"      , AV_CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
 295         { "dts"      , AV_CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
 296         { "eac3"     , AV_CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
 297         { "h264"     , AV_CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
 298         { "loas"     , AV_CODEC_ID_AAC_LATM  , AVMEDIA_TYPE_AUDIO },
 299         { "m4v"      , AV_CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
 300         { "mp3"      , AV_CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
 301         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 302         { 0 }
 303     };
 304     int score;
 305     AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
 306
 307     if (fmt && st->request_probe <= score) {
 308         int i;
 309         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
 310                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
 311         for (i = 0; fmt_id_type[i].name; i++) {
 312             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 313                 st->codec->codec_id   = fmt_id_type[i].id;
 314                 st->codec->codec_type = fmt_id_type[i].type;
 315                 break;
 316             }
 317         }
 318     }
 319     return score;
 320 }
 321
 322 /************************************************************/
 323 /* input media file */
 324
 325 int av_demuxer_open(AVFormatContext *ic){
 326     int err;
 327
 328     if (ic->iformat->read_header) {
 329         err = ic->iformat->read_header(ic);
 330         if (err < 0)
 331             return err;
 332     }
 333
 334     if (ic->pb && !ic->data_offset)
 335         ic->data_offset = avio_tell(ic->pb);
 336
 337     return 0;
 338 }
 339
 340
 341 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
 342                           const char *filename, void *logctx,
 343                           unsigned int offset, unsigned int max_probe_size)
 344 {
 345     AVProbeData pd = { filename ? filename : "", NULL, -offset };
 346     unsigned char *buf = NULL;
 347     uint8_t *mime_type;
 348     int ret = 0, probe_size, buf_offset = 0;
 349     int score = 0;
 350
 351     if (!max_probe_size) {
 352         max_probe_size = PROBE_BUF_MAX;
 353     } else if (max_probe_size > PROBE_BUF_MAX) {
 354         max_probe_size = PROBE_BUF_MAX;
 355     } else if (max_probe_size < PROBE_BUF_MIN) {
 356         av_log(logctx, AV_LOG_ERROR,
 357                "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
 358         return AVERROR(EINVAL);
 359     }
 360
 361     if (offset >= max_probe_size) {
 362         return AVERROR(EINVAL);
 363     }
 364
 365     if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
 366         if (!av_strcasecmp(mime_type, "audio/aacp")) {
 367             *fmt = av_find_input_format("aac");
 368         }
 369         av_freep(&mime_type);
 370     }
 371
 372     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
 373         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
 374
 375         if (probe_size < offset) {
 376             continue;
 377         }
 378         score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
 379
 380         /* read probe data */
 381         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
 382             return ret;
 383         if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
 384             /* fail if error was not end of file, otherwise, lower score */
 385             if (ret != AVERROR_EOF) {
 386                 av_free(buf);
 387                 return ret;
 388             }
 389             score = 0;
 390             ret = 0;            /* error was end of file, nothing read */
 391         }
 392         pd.buf_size = buf_offset += ret;
 393         pd.buf = &buf[offset];
 394
 395         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
 396
 397         /* guess file format */
 398         *fmt = av_probe_input_format2(&pd, 1, &score);
 399         if(*fmt){
 400             if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
 401                 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
 402             }else
 403                 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
 404 #if 0
 405             FILE *f = fopen("probestat.tmp", "ab");
 406             fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
 407             fclose(f);
 408 #endif
 409         }
 410     }
 411
 412     if (!*fmt) {
 413         av_free(buf);
 414         return AVERROR_INVALIDDATA;
 415     }
 416
 417     /* rewind. reuse probe buffer to avoid seeking */
 418     ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
 419
 420     return ret < 0 ? ret : score;
 421 }
 422
 423 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
 424                           const char *filename, void *logctx,
 425                           unsigned int offset, unsigned int max_probe_size)
 426 {
 427     int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
 428     return ret < 0 ? ret : 0;
 429 }
 430
 431
 432 /* open input file and probe the format if necessary */
 433 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
 434 {
 435     int ret;
 436     AVProbeData pd = {filename, NULL, 0};
 437     int score = AVPROBE_SCORE_RETRY;
 438
 439     if (s->pb) {
 440         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 441         if (!s->iformat)
 442             return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
 443         else if (s->iformat->flags & AVFMT_NOFILE)
 444             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
 445                                       "will be ignored with AVFMT_NOFILE format.\n");
 446         return 0;
 447     }
 448
 449     if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
 450         (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
 451         return score;
 452
 453     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
 454                           &s->interrupt_callback, options)) < 0)
 455         return ret;
 456     if (s->iformat)
 457         return 0;
 458     return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
 459 }
 460
 461 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 462                                AVPacketList **plast_pktl){
 463     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 464     if (!pktl)
 465         return NULL;
 466
 467     if (*packet_buffer)
 468         (*plast_pktl)->next = pktl;
 469     else
 470         *packet_buffer = pktl;
 471
 472     /* add the packet in the buffered packet list */
 473     *plast_pktl = pktl;
 474     pktl->pkt= *pkt;
 475     return &pktl->pkt;
 476 }
 477
 478 int avformat_queue_attached_pictures(AVFormatContext *s)
 479 {
 480     int i;
 481     for (i = 0; i < s->nb_streams; i++)
 482         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
 483             s->streams[i]->discard < AVDISCARD_ALL) {
 484             AVPacket copy = s->streams[i]->attached_pic;
 485             copy.buf      = av_buffer_ref(copy.buf);
 486             if (!copy.buf)
 487                 return AVERROR(ENOMEM);
 488
 489             add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
 490         }
 491     return 0;
 492 }
 493
 494 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
 495 {
 496     AVFormatContext *s = *ps;
 497     int ret = 0;
 498     AVDictionary *tmp = NULL;
 499     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
 500
 501     if (!s && !(s = avformat_alloc_context()))
 502         return AVERROR(ENOMEM);
 503     if (!s->av_class){
 504         av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
 505         return AVERROR(EINVAL);
 506     }
 507     if (fmt)
 508         s->iformat = fmt;
 509
 510     if (options)
 511         av_dict_copy(&tmp, *options, 0);
 512
 513     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
 514         goto fail;
 515
 516     if ((ret = init_input(s, filename, &tmp)) < 0)
 517         goto fail;
 518     s->probe_score = ret;
 519     avio_skip(s->pb, s->skip_initial_bytes);
 520
 521     /* check filename in case an image number is expected */
 522     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
 523         if (!av_filename_number_test(filename)) {
 524             ret = AVERROR(EINVAL);
 525             goto fail;
 526         }
 527     }
 528
 529     s->duration = s->start_time = AV_NOPTS_VALUE;
 530     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
 531
 532     /* allocate private data */
 533     if (s->iformat->priv_data_size > 0) {
 534         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
 535             ret = AVERROR(ENOMEM);
 536             goto fail;
 537         }
 538         if (s->iformat->priv_class) {
 539             *(const AVClass**)s->priv_data = s->iformat->priv_class;
 540             av_opt_set_defaults(s->priv_data);
 541             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 542                 goto fail;
 543         }
 544     }
 545
 546     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
 547     if (s->pb)
 548         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
 549
 550     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
 551         if ((ret = s->iformat->read_header(s)) < 0)
 552             goto fail;
 553
 554     if (id3v2_extra_meta) {
 555         if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
 556             !strcmp(s->iformat->name, "tta")) {
 557             if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
 558                 goto fail;
 559         } else
 560             av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
 561     }
 562     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 563
 564     if ((ret = avformat_queue_attached_pictures(s)) < 0)
 565         goto fail;
 566
 567     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
 568         s->data_offset = avio_tell(s->pb);
 569
 570     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 571
 572     if (options) {
 573         av_dict_free(options);
 574         *options = tmp;
 575     }
 576     *ps = s;
 577     return 0;
 578
 579 fail:
 580     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 581     av_dict_free(&tmp);
 582     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
 583         avio_close(s->pb);
 584     avformat_free_context(s);
 585     *ps = NULL;
 586     return ret;
 587 }
 588
 589 /*******************************************************/
 590
 591 static void force_codec_ids(AVFormatContext *s, AVStream *st)
 592 {
 593     switch(st->codec->codec_type){
 594     case AVMEDIA_TYPE_VIDEO:
 595         if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
 596         break;
 597     case AVMEDIA_TYPE_AUDIO:
 598         if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
 599         break;
 600     case AVMEDIA_TYPE_SUBTITLE:
 601         if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
 602         break;
 603     }
 604 }
 605
 606 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
 607 {
 608     if(st->request_probe>0){
 609         AVProbeData *pd = &st->probe_data;
 610         int end;
 611         av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
 612         --st->probe_packets;
 613
 614         if (pkt) {
 615             uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 616             if(!new_buf) {
 617                 av_log(s, AV_LOG_WARNING,
 618                        "Failed to reallocate probe buffer for stream %d\n",
 619                        st->index);
 620                 goto no_packet;
 621             }
 622             pd->buf = new_buf;
 623             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
 624             pd->buf_size += pkt->size;
 625             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 626         } else {
 627 no_packet:
 628             st->probe_packets = 0;
 629             if (!pd->buf_size) {
 630                 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
 631                        st->index);
 632             }
 633         }
 634
 635         end=    s->raw_packet_buffer_remaining_size <= 0
 636                 || st->probe_packets<=0;
 637
 638         if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
 639             int score= set_codec_from_probe_data(s, st, pd);
 640             if(    (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
 641                 || end){
 642                 pd->buf_size=0;
 643                 av_freep(&pd->buf);
 644                 st->request_probe= -1;
 645                 if(st->codec->codec_id != AV_CODEC_ID_NONE){
 646                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 647                 }else
 648                     av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
 649             }
 650             force_codec_ids(s, st);
 651         }
 652     }
 653     return 0;
 654 }
 655
 656 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
 657 {
 658     int64_t ref = pkt->dts;
 659     int i, pts_wrap_behavior;
 660     int64_t pts_wrap_reference;
 661     AVProgram *first_program;
 662
 663     if (ref == AV_NOPTS_VALUE)
 664         ref = pkt->pts;
 665     if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
 666         return 0;
 667     ref &= (1LL<<st->pts_wrap_bits)-1;
 668
 669     // reference time stamp should be 60 s before first time stamp
 670     pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
 671     // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
 672     pts_wrap_behavior = (ref < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
 673         (ref < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
 674         AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
 675
 676     first_program = av_find_program_from_stream(s, NULL, stream_index);
 677
 678     if (!first_program) {
 679         int default_stream_index = av_find_default_stream_index(s);
 680         if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
 681             for (i=0; i<s->nb_streams; i++) {
 682                 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
 683                 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
 684             }
 685         }
 686         else {
 687             st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
 688             st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
 689         }
 690     }
 691     else {
 692         AVProgram *program = first_program;
 693         while (program) {
 694             if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
 695                 pts_wrap_reference = program->pts_wrap_reference;
 696                 pts_wrap_behavior = program->pts_wrap_behavior;
 697                 break;
 698             }
 699             program = av_find_program_from_stream(s, program, stream_index);
 700         }
 701
 702         // update every program with differing pts_wrap_reference
 703         program = first_program;
 704         while(program) {
 705             if (program->pts_wrap_reference != pts_wrap_reference) {
 706                 for (i=0; i<program->nb_stream_indexes; i++) {
 707                     s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
 708                     s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
 709                 }
 710
 711                 program->pts_wrap_reference = pts_wrap_reference;
 712                 program->pts_wrap_behavior = pts_wrap_behavior;
 713             }
 714             program = av_find_program_from_stream(s, program, stream_index);
 715         }
 716     }
 717     return 1;
 718 }
 719
 720 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
 721 {
 722     int ret, i, err;
 723     AVStream *st;
 724
 725     for(;;){
 726         AVPacketList *pktl = s->raw_packet_buffer;
 727
 728         if (pktl) {
 729             *pkt = pktl->pkt;
 730             st = s->streams[pkt->stream_index];
 731             if (s->raw_packet_buffer_remaining_size <= 0) {
 732                 if ((err = probe_codec(s, st, NULL)) < 0)
 733                     return err;
 734             }
 735             if(st->request_probe <= 0){
 736                 s->raw_packet_buffer = pktl->next;
 737                 s->raw_packet_buffer_remaining_size += pkt->size;
 738                 av_free(pktl);
 739                 return 0;
 740             }
 741         }
 742
 743         pkt->data = NULL;
 744         pkt->size = 0;
 745         av_init_packet(pkt);
 746         ret= s->iformat->read_packet(s, pkt);
 747         if (ret < 0) {
 748             if (!pktl || ret == AVERROR(EAGAIN))
 749                 return ret;
 750             for (i = 0; i < s->nb_streams; i++) {
 751                 st = s->streams[i];
 752                 if (st->probe_packets) {
 753                     if ((err = probe_codec(s, st, NULL)) < 0)
 754                         return err;
 755                 }
 756                 av_assert0(st->request_probe <= 0);
 757             }
 758             continue;
 759         }
 760
 761         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
 762             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
 763             av_log(s, AV_LOG_WARNING,
 764                    "Dropped corrupted packet (stream = %d)\n",
 765                    pkt->stream_index);
 766             av_free_packet(pkt);
 767             continue;
 768         }
 769
 770         if(pkt->stream_index >= (unsigned)s->nb_streams){
 771             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
 772             continue;
 773         }
 774
 775         st= s->streams[pkt->stream_index];
 776
 777         if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
 778             // correct first time stamps to negative values
 779             if (!is_relative(st->first_dts))
 780                 st->first_dts = wrap_timestamp(st, st->first_dts);
 781             if (!is_relative(st->start_time))
 782                 st->start_time = wrap_timestamp(st, st->start_time);
 783             if (!is_relative(st->cur_dts))
 784                 st->cur_dts = wrap_timestamp(st, st->cur_dts);
 785         }
 786
 787         pkt->dts = wrap_timestamp(st, pkt->dts);
 788         pkt->pts = wrap_timestamp(st, pkt->pts);
 789
 790         force_codec_ids(s, st);
 791
 792         /* TODO: audio: time filter; video: frame reordering (pts != dts) */
 793         if (s->use_wallclock_as_timestamps)
 794             pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
 795
 796         if(!pktl && st->request_probe <= 0)
 797             return ret;
 798
 799         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
 800         s->raw_packet_buffer_remaining_size -= pkt->size;
 801
 802         if ((err = probe_codec(s, st, pkt)) < 0)
 803             return err;
 804     }
 805 }
 806
 807 #if FF_API_READ_PACKET
 808 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
 809 {
 810     return ff_read_packet(s, pkt);
 811 }
 812 #endif
 813
 814
 815 /**********************************************************/
 816
 817 static int determinable_frame_size(AVCodecContext *avctx)
 818 {
 819     if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
 820         avctx->codec_id == AV_CODEC_ID_MP1 ||
 821         avctx->codec_id == AV_CODEC_ID_MP2 ||
 822         avctx->codec_id == AV_CODEC_ID_MP3/* ||
 823         avctx->codec_id == AV_CODEC_ID_CELT*/)
 824         return 1;
 825     return 0;
 826 }
 827
 828 /**
 829  * Get the number of samples of an audio frame. Return -1 on error.
 830  */
 831 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
 832 {
 833     int frame_size;
 834
 835     /* give frame_size priority if demuxing */
 836     if (!mux && enc->frame_size > 1)
 837         return enc->frame_size;
 838
 839     if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
 840         return frame_size;
 841
 842     /* Fall back on using frame_size if muxing. */
 843     if (enc->frame_size > 1)
 844         return enc->frame_size;
 845
 846     //For WMA we currently have no other means to calculate duration thus we
 847     //do it here by assuming CBR, which is true for all known cases.
 848     if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
 849         if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
 850             return  ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
 851     }
 852
 853     return -1;
 854 }
 855
 856
 857 /**
 858  * Return the frame duration in seconds. Return 0 if not available.
 859  */
 860 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
 861                                AVCodecParserContext *pc, AVPacket *pkt)
 862 {
 863     int frame_size;
 864
 865     *pnum = 0;
 866     *pden = 0;
 867     switch(st->codec->codec_type) {
 868     case AVMEDIA_TYPE_VIDEO:
 869         if (st->r_frame_rate.num && !pc) {
 870             *pnum = st->r_frame_rate.den;
 871             *pden = st->r_frame_rate.num;
 872         } else if(st->time_base.num*1000LL > st->time_base.den) {
 873             *pnum = st->time_base.num;
 874             *pden = st->time_base.den;
 875         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
 876             *pnum = st->codec->time_base.num;
 877             *pden = st->codec->time_base.den;
 878             if (pc && pc->repeat_pict) {
 879                 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
 880                     *pden /= 1 + pc->repeat_pict;
 881                 else
 882                     *pnum *= 1 + pc->repeat_pict;
 883             }
 884             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
 885             //Thus if we have no parser in such case leave duration undefined.
 886             if(st->codec->ticks_per_frame>1 && !pc){
 887                 *pnum = *pden = 0;
 888             }
 889         }
 890         break;
 891     case AVMEDIA_TYPE_AUDIO:
 892         frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
 893         if (frame_size <= 0 || st->codec->sample_rate <= 0)
 894             break;
 895         *pnum = frame_size;
 896         *pden = st->codec->sample_rate;
 897         break;
 898     default:
 899         break;
 900     }
 901 }
 902
 903 static int is_intra_only(AVCodecContext *enc){
 904     const AVCodecDescriptor *desc;
 905
 906     if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
 907         return 1;
 908
 909     desc = av_codec_get_codec_descriptor(enc);
 910     if (!desc) {
 911         desc = avcodec_descriptor_get(enc->codec_id);
 912         av_codec_set_codec_descriptor(enc, desc);
 913     }
 914     if (desc)
 915         return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
 916     return 0;
 917 }
 918
 919 static int has_decode_delay_been_guessed(AVStream *st)
 920 {
 921     if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
 922     if(!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
 923         return 1;
 924 #if CONFIG_H264_DECODER
 925     if(st->codec->has_b_frames &&
 926        avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
 927         return 1;
 928 #endif
 929     if(st->codec->has_b_frames<3)
 930         return st->nb_decoded_frames >= 7;
 931     else if(st->codec->has_b_frames<4)
 932         return st->nb_decoded_frames >= 18;
 933     else
 934         return st->nb_decoded_frames >= 20;
 935 }
 936
 937 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
 938 {
 939     if (pktl->next)
 940         return pktl->next;
 941     if (pktl == s->parse_queue_end)
 942         return s->packet_buffer;
 943     return NULL;
 944 }
 945
 946 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 947                                       int64_t dts, int64_t pts, AVPacket *pkt)
 948 {
 949     AVStream *st= s->streams[stream_index];
 950     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
 951     int64_t pts_buffer[MAX_REORDER_DELAY+1];
 952     int64_t shift;
 953     int i, delay;
 954
 955     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
 956         return;
 957
 958     delay = st->codec->has_b_frames;
 959     st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
 960     st->cur_dts= dts;
 961     shift = st->first_dts - RELATIVE_TS_BASE;
 962
 963     for (i=0; i<MAX_REORDER_DELAY+1; i++)
 964         pts_buffer[i] = AV_NOPTS_VALUE;
 965
 966     if (is_relative(pts))
 967         pts += shift;
 968
 969     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
 970         if(pktl->pkt.stream_index != stream_index)
 971             continue;
 972         if(is_relative(pktl->pkt.pts))
 973             pktl->pkt.pts += shift;
 974
 975         if(is_relative(pktl->pkt.dts))
 976             pktl->pkt.dts += shift;
 977
 978         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 979             st->start_time= pktl->pkt.pts;
 980
 981         if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
 982             pts_buffer[0]= pktl->pkt.pts;
 983             for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
 984                 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
 985             if(pktl->pkt.dts == AV_NOPTS_VALUE)
 986                 pktl->pkt.dts= pts_buffer[0];
 987         }
 988     }
 989
 990     if (st->start_time == AV_NOPTS_VALUE)
 991         st->start_time = pts;
 992 }
 993
 994 static void update_initial_durations(AVFormatContext *s, AVStream *st,
 995                                      int stream_index, int duration)
 996 {
 997     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
 998     int64_t cur_dts= RELATIVE_TS_BASE;
 999
1000     if(st->first_dts != AV_NOPTS_VALUE){
1001         cur_dts= st->first_dts;
1002         for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1003             if(pktl->pkt.stream_index == stream_index){
1004                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
1005                     break;
1006                 cur_dts -= duration;
1007             }
1008         }
1009         if(pktl && pktl->pkt.dts != st->first_dts) {
1010             av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1011                    av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1012             return;
1013         }
1014         if(!pktl) {
1015             av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1016             return;
1017         }
1018         pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1019         st->first_dts = cur_dts;
1020     }else if(st->cur_dts != RELATIVE_TS_BASE)
1021         return;
1022
1023     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1024         if(pktl->pkt.stream_index != stream_index)
1025             continue;
1026         if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1027            && !pktl->pkt.duration){
1028             pktl->pkt.dts= cur_dts;
1029             if(!st->codec->has_b_frames)
1030                 pktl->pkt.pts= cur_dts;
1031 //            if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1032                 pktl->pkt.duration = duration;
1033         }else
1034             break;
1035         cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1036     }
1037     if(!pktl)
1038         st->cur_dts= cur_dts;
1039 }
1040
1041 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1042                                AVCodecParserContext *pc, AVPacket *pkt)
1043 {
1044     int num, den, presentation_delayed, delay, i;
1045     int64_t offset;
1046
1047     if (s->flags & AVFMT_FLAG_NOFILLIN)
1048         return;
1049
1050     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1051         pkt->dts= AV_NOPTS_VALUE;
1052
1053     if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1054         && !st->codec->has_b_frames)
1055         //FIXME Set low_delay = 0 when has_b_frames = 1
1056         st->codec->has_b_frames = 1;
1057
1058     /* do we have a video B-frame ? */
1059     delay= st->codec->has_b_frames;
1060     presentation_delayed = 0;
1061
1062     /* XXX: need has_b_frame, but cannot get it if the codec is
1063         not initialized */
1064     if (delay &&
1065         pc && pc->pict_type != AV_PICTURE_TYPE_B)
1066         presentation_delayed = 1;
1067
1068     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1069         st->pts_wrap_bits < 63 &&
1070         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1071         if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1072             pkt->dts -= 1LL<<st->pts_wrap_bits;
1073         } else
1074             pkt->pts += 1LL<<st->pts_wrap_bits;
1075     }
1076
1077     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1078     // we take the conservative approach and discard both
1079     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1080     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1081         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1082         if (    strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1083              && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1084             pkt->dts= AV_NOPTS_VALUE;
1085     }
1086
1087     if (pkt->duration == 0) {
1088         ff_compute_frame_duration(&num, &den, st, pc, pkt);
1089         if (den && num) {
1090             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1091         }
1092     }
1093     if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1094         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1095
1096     /* correct timestamps with byte offset if demuxers only have timestamps
1097        on packet boundaries */
1098     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1099         /* this will estimate bitrate based on this frame's duration and size */
1100         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1101         if(pkt->pts != AV_NOPTS_VALUE)
1102             pkt->pts += offset;
1103         if(pkt->dts != AV_NOPTS_VALUE)
1104             pkt->dts += offset;
1105     }
1106
1107     /* This may be redundant, but it should not hurt. */
1108     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1109         presentation_delayed = 1;
1110
1111     av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1112            presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1113     /* interpolate PTS and DTS if they are not present */
1114     //We skip H264 currently because delay and has_b_frames are not reliably set
1115     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1116         if (presentation_delayed) {
1117             /* DTS = decompression timestamp */
1118             /* PTS = presentation timestamp */
1119             if (pkt->dts == AV_NOPTS_VALUE)
1120                 pkt->dts = st->last_IP_pts;
1121             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1122             if (pkt->dts == AV_NOPTS_VALUE)
1123                 pkt->dts = st->cur_dts;
1124
1125             /* this is tricky: the dts must be incremented by the duration
1126             of the frame we are displaying, i.e. the last I- or P-frame */
1127             if (st->last_IP_duration == 0)
1128                 st->last_IP_duration = pkt->duration;
1129             if(pkt->dts != AV_NOPTS_VALUE)
1130                 st->cur_dts = pkt->dts + st->last_IP_duration;
1131             st->last_IP_duration  = pkt->duration;
1132             st->last_IP_pts= pkt->pts;
1133             /* cannot compute PTS if not present (we can compute it only
1134             by knowing the future */
1135         } else if (pkt->pts != AV_NOPTS_VALUE ||
1136                    pkt->dts != AV_NOPTS_VALUE ||
1137                    pkt->duration                ) {
1138             int duration = pkt->duration;
1139
1140             /* presentation is not delayed : PTS and DTS are the same */
1141             if (pkt->pts == AV_NOPTS_VALUE)
1142                 pkt->pts = pkt->dts;
1143             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1144                                       pkt->pts, pkt);
1145             if (pkt->pts == AV_NOPTS_VALUE)
1146                 pkt->pts = st->cur_dts;
1147             pkt->dts = pkt->pts;
1148             if (pkt->pts != AV_NOPTS_VALUE)
1149                 st->cur_dts = pkt->pts + duration;
1150         }
1151     }
1152
1153     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1154         st->pts_buffer[0]= pkt->pts;
1155         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1156             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1157         if(pkt->dts == AV_NOPTS_VALUE)
1158             pkt->dts= st->pts_buffer[0];
1159     }
1160     if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1161         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1162     }
1163     if(pkt->dts > st->cur_dts)
1164         st->cur_dts = pkt->dts;
1165
1166     av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1167             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1168
1169     /* update flags */
1170     if (is_intra_only(st->codec))
1171         pkt->flags |= AV_PKT_FLAG_KEY;
1172     if (pc)
1173         pkt->convergence_duration = pc->convergence_duration;
1174 }
1175
1176 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1177 {
1178     while (*pkt_buf) {
1179         AVPacketList *pktl = *pkt_buf;
1180         *pkt_buf = pktl->next;
1181         av_free_packet(&pktl->pkt);
1182         av_freep(&pktl);
1183     }
1184     *pkt_buf_end = NULL;
1185 }
1186
1187 /**
1188  * Parse a packet, add all split parts to parse_queue
1189  *
1190  * @param pkt packet to parse, NULL when flushing the parser at end of stream
1191  */
1192 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1193 {
1194     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1195     AVStream     *st = s->streams[stream_index];
1196     uint8_t    *data = pkt ? pkt->data : NULL;
1197     int         size = pkt ? pkt->size : 0;
1198     int ret = 0, got_output = 0;
1199
1200     if (!pkt) {
1201         av_init_packet(&flush_pkt);
1202         pkt = &flush_pkt;
1203         got_output = 1;
1204     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1205         // preserve 0-size sync packets
1206         compute_pkt_fields(s, st, st->parser, pkt);
1207     }
1208
1209     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1210         int len;
1211
1212         av_init_packet(&out_pkt);
1213         len = av_parser_parse2(st->parser,  st->codec,
1214                                &out_pkt.data, &out_pkt.size, data, size,
1215                                pkt->pts, pkt->dts, pkt->pos);
1216
1217         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1218         pkt->pos = -1;
1219         /* increment read pointer */
1220         data += len;
1221         size -= len;
1222
1223         got_output = !!out_pkt.size;
1224
1225         if (!out_pkt.size)
1226             continue;
1227
1228         if (pkt->side_data) {
1229             out_pkt.side_data       = pkt->side_data;
1230             out_pkt.side_data_elems = pkt->side_data_elems;
1231             pkt->side_data       = NULL;
1232             pkt->side_data_elems = 0;
1233         }
1234
1235         /* set the duration */
1236         out_pkt.duration = 0;
1237         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1238             if (st->codec->sample_rate > 0) {
1239                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1240                                                     (AVRational){ 1, st->codec->sample_rate },
1241                                                     st->time_base,
1242                                                     AV_ROUND_DOWN);
1243             }
1244         } else if (st->codec->time_base.num != 0 &&
1245                    st->codec->time_base.den != 0) {
1246             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1247                                                 st->codec->time_base,
1248                                                 st->time_base,
1249                                                 AV_ROUND_DOWN);
1250         }
1251
1252         out_pkt.stream_index = st->index;
1253         out_pkt.pts = st->parser->pts;
1254         out_pkt.dts = st->parser->dts;
1255         out_pkt.pos = st->parser->pos;
1256
1257         if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1258             out_pkt.pos = st->parser->frame_offset;
1259
1260         if (st->parser->key_frame == 1 ||
1261             (st->parser->key_frame == -1 &&
1262              st->parser->pict_type == AV_PICTURE_TYPE_I))
1263             out_pkt.flags |= AV_PKT_FLAG_KEY;
1264
1265         if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1266             out_pkt.flags |= AV_PKT_FLAG_KEY;
1267
1268         compute_pkt_fields(s, st, st->parser, &out_pkt);
1269
1270         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1271             out_pkt.buf   = pkt->buf;
1272             pkt->buf      = NULL;
1273 #if FF_API_DESTRUCT_PACKET
1274 FF_DISABLE_DEPRECATION_WARNINGS
1275             out_pkt.destruct = pkt->destruct;
1276             pkt->destruct = NULL;
1277 FF_ENABLE_DEPRECATION_WARNINGS
1278 #endif
1279         }
1280         if ((ret = av_dup_packet(&out_pkt)) < 0)
1281             goto fail;
1282
1283         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1284             av_free_packet(&out_pkt);
1285             ret = AVERROR(ENOMEM);
1286             goto fail;
1287         }
1288     }
1289
1290
1291     /* end of the stream => close and free the parser */
1292     if (pkt == &flush_pkt) {
1293         av_parser_close(st->parser);
1294         st->parser = NULL;
1295     }
1296
1297 fail:
1298     av_free_packet(pkt);
1299     return ret;
1300 }
1301
1302 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1303                                    AVPacketList **pkt_buffer_end,
1304                                    AVPacket      *pkt)
1305 {
1306     AVPacketList *pktl;
1307     av_assert0(*pkt_buffer);
1308     pktl = *pkt_buffer;
1309     *pkt = pktl->pkt;
1310     *pkt_buffer = pktl->next;
1311     if (!pktl->next)
1312         *pkt_buffer_end = NULL;
1313     av_freep(&pktl);
1314     return 0;
1315 }
1316
1317 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1318 {
1319     int ret = 0, i, got_packet = 0;
1320
1321     av_init_packet(pkt);
1322
1323     while (!got_packet && !s->parse_queue) {
1324         AVStream *st;
1325         AVPacket cur_pkt;
1326
1327         /* read next packet */
1328         ret = ff_read_packet(s, &cur_pkt);
1329         if (ret < 0) {
1330             if (ret == AVERROR(EAGAIN))
1331                 return ret;
1332             /* flush the parsers */
1333             for(i = 0; i < s->nb_streams; i++) {
1334                 st = s->streams[i];
1335                 if (st->parser && st->need_parsing)
1336                     parse_packet(s, NULL, st->index);
1337             }
1338             /* all remaining packets are now in parse_queue =>
1339              * really terminate parsing */
1340             break;
1341         }
1342         ret = 0;
1343         st  = s->streams[cur_pkt.stream_index];
1344
1345         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1346             cur_pkt.dts != AV_NOPTS_VALUE &&
1347             cur_pkt.pts < cur_pkt.dts) {
1348             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1349                    cur_pkt.stream_index,
1350                    av_ts2str(cur_pkt.pts),
1351                    av_ts2str(cur_pkt.dts),
1352                    cur_pkt.size);
1353         }
1354         if (s->debug & FF_FDEBUG_TS)
1355             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1356                    cur_pkt.stream_index,
1357                    av_ts2str(cur_pkt.pts),
1358                    av_ts2str(cur_pkt.dts),
1359                    cur_pkt.size,
1360                    cur_pkt.duration,
1361                    cur_pkt.flags);
1362
1363         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1364             st->parser = av_parser_init(st->codec->codec_id);
1365             if (!st->parser) {
1366                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1367                        "%s, packets or times may be invalid.\n",
1368                        avcodec_get_name(st->codec->codec_id));
1369                 /* no parser available: just output the raw packets */
1370                 st->need_parsing = AVSTREAM_PARSE_NONE;
1371             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1372                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1373             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1374                 st->parser->flags |= PARSER_FLAG_ONCE;
1375             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1376                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1377             }
1378         }
1379
1380         if (!st->need_parsing || !st->parser) {
1381             /* no parsing needed: we just output the packet as is */
1382             *pkt = cur_pkt;
1383             compute_pkt_fields(s, st, NULL, pkt);
1384             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1385                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1386                 ff_reduce_index(s, st->index);
1387                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1388             }
1389             got_packet = 1;
1390         } else if (st->discard < AVDISCARD_ALL) {
1391             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1392                 return ret;
1393         } else {
1394             /* free packet */
1395             av_free_packet(&cur_pkt);
1396         }
1397         if (pkt->flags & AV_PKT_FLAG_KEY)
1398             st->skip_to_keyframe = 0;
1399         if (st->skip_to_keyframe) {
1400             av_free_packet(&cur_pkt);
1401             if (got_packet) {
1402                 *pkt = cur_pkt;
1403             }
1404             got_packet = 0;
1405         }
1406     }
1407
1408     if (!got_packet && s->parse_queue)
1409         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1410
1411     if (ret >= 0) {
1412         AVStream *st = s->streams[pkt->stream_index];
1413         if (st->skip_samples) {
1414             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1415             if (p) {
1416                 AV_WL32(p, st->skip_samples);
1417                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1418             }
1419             st->skip_samples = 0;
1420         }
1421     }
1422
1423     if(ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1424         av_packet_merge_side_data(pkt);
1425
1426     if(s->debug & FF_FDEBUG_TS)
1427         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1428             pkt->stream_index,
1429             av_ts2str(pkt->pts),
1430             av_ts2str(pkt->dts),
1431             pkt->size,
1432             pkt->duration,
1433             pkt->flags);
1434
1435     return ret;
1436 }
1437
1438 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1439 {
1440     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1441     int          eof = 0;
1442     int ret;
1443     AVStream *st;
1444
1445     if (!genpts) {
1446         ret = s->packet_buffer ?
1447             read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1448             read_frame_internal(s, pkt);
1449         if (ret < 0)
1450             return ret;
1451         goto return_packet;
1452     }
1453
1454     for (;;) {
1455         AVPacketList *pktl = s->packet_buffer;
1456
1457         if (pktl) {
1458             AVPacket *next_pkt = &pktl->pkt;
1459
1460             if (next_pkt->dts != AV_NOPTS_VALUE) {
1461                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1462                 // last dts seen for this stream. if any of packets following
1463                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1464                 int64_t last_dts = next_pkt->dts;
1465                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1466                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1467                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1468                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1469                             next_pkt->pts = pktl->pkt.dts;
1470                         }
1471                         if (last_dts != AV_NOPTS_VALUE) {
1472                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1473                             last_dts = pktl->pkt.dts;
1474                         }
1475                     }
1476                     pktl = pktl->next;
1477                 }
1478                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1479                     // Fixing the last reference frame had none pts issue (For MXF etc).
1480                     // We only do this when
1481                     // 1. eof.
1482                     // 2. we are not able to resolve a pts value for current packet.
1483                     // 3. the packets for this stream at the end of the files had valid dts.
1484                     next_pkt->pts = last_dts + next_pkt->duration;
1485                 }
1486                 pktl = s->packet_buffer;
1487             }
1488
1489             /* read packet from packet buffer, if there is data */
1490             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1491                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1492                 ret = read_from_packet_buffer(&s->packet_buffer,
1493                                                &s->packet_buffer_end, pkt);
1494                 goto return_packet;
1495             }
1496         }
1497
1498         ret = read_frame_internal(s, pkt);
1499         if (ret < 0) {
1500             if (pktl && ret != AVERROR(EAGAIN)) {
1501                 eof = 1;
1502                 continue;
1503             } else
1504                 return ret;
1505         }
1506
1507         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1508                           &s->packet_buffer_end)) < 0)
1509             return AVERROR(ENOMEM);
1510     }
1511
1512 return_packet:
1513
1514     st = s->streams[pkt->stream_index];
1515     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1516         ff_reduce_index(s, st->index);
1517         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1518     }
1519
1520     if (is_relative(pkt->dts))
1521         pkt->dts -= RELATIVE_TS_BASE;
1522     if (is_relative(pkt->pts))
1523         pkt->pts -= RELATIVE_TS_BASE;
1524
1525     return ret;
1526 }
1527
1528 /* XXX: suppress the packet queue */
1529 static void flush_packet_queue(AVFormatContext *s)
1530 {
1531     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1532     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1533     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1534
1535     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1536 }
1537
1538 /*******************************************************/
1539 /* seek support */
1540
1541 int av_find_default_stream_index(AVFormatContext *s)
1542 {
1543     int first_audio_index = -1;
1544     int i;
1545     AVStream *st;
1546
1547     if (s->nb_streams <= 0)
1548         return -1;
1549     for(i = 0; i < s->nb_streams; i++) {
1550         st = s->streams[i];
1551         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1552             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1553             return i;
1554         }
1555         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1556             first_audio_index = i;
1557     }
1558     return first_audio_index >= 0 ? first_audio_index : 0;
1559 }
1560
1561 /**
1562  * Flush the frame reader.
1563  */
1564 void ff_read_frame_flush(AVFormatContext *s)
1565 {
1566     AVStream *st;
1567     int i, j;
1568
1569     flush_packet_queue(s);
1570
1571     /* for each stream, reset read state */
1572     for(i = 0; i < s->nb_streams; i++) {
1573         st = s->streams[i];
1574
1575         if (st->parser) {
1576             av_parser_close(st->parser);
1577             st->parser = NULL;
1578         }
1579         st->last_IP_pts = AV_NOPTS_VALUE;
1580         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1581         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1582
1583         st->probe_packets = MAX_PROBE_PACKETS;
1584
1585         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1586             st->pts_buffer[j]= AV_NOPTS_VALUE;
1587     }
1588 }
1589
1590 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1591 {
1592     int i;
1593
1594     for(i = 0; i < s->nb_streams; i++) {
1595         AVStream *st = s->streams[i];
1596
1597         st->cur_dts = av_rescale(timestamp,
1598                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1599                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1600     }
1601 }
1602
1603 void ff_reduce_index(AVFormatContext *s, int stream_index)
1604 {
1605     AVStream *st= s->streams[stream_index];
1606     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1607
1608     if((unsigned)st->nb_index_entries >= max_entries){
1609         int i;
1610         for(i=0; 2*i<st->nb_index_entries; i++)
1611             st->index_entries[i]= st->index_entries[2*i];
1612         st->nb_index_entries= i;
1613     }
1614 }
1615
1616 int ff_add_index_entry(AVIndexEntry **index_entries,
1617                        int *nb_index_entries,
1618                        unsigned int *index_entries_allocated_size,
1619                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1620 {
1621     AVIndexEntry *entries, *ie;
1622     int index;
1623
1624     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1625         return -1;
1626
1627     if(timestamp == AV_NOPTS_VALUE)
1628         return AVERROR(EINVAL);
1629
1630     if (size < 0 || size > 0x3FFFFFFF)
1631         return AVERROR(EINVAL);
1632
1633     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1634         timestamp -= RELATIVE_TS_BASE;
1635
1636     entries = av_fast_realloc(*index_entries,
1637                               index_entries_allocated_size,
1638                               (*nb_index_entries + 1) *
1639                               sizeof(AVIndexEntry));
1640     if(!entries)
1641         return -1;
1642
1643     *index_entries= entries;
1644
1645     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1646
1647     if(index<0){
1648         index= (*nb_index_entries)++;
1649         ie= &entries[index];
1650         av_assert0(index==0 || ie[-1].timestamp < timestamp);
1651     }else{
1652         ie= &entries[index];
1653         if(ie->timestamp != timestamp){
1654             if(ie->timestamp <= timestamp)
1655                 return -1;
1656             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1657             (*nb_index_entries)++;
1658         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1659             distance= ie->min_distance;
1660     }
1661
1662     ie->pos = pos;
1663     ie->timestamp = timestamp;
1664     ie->min_distance= distance;
1665     ie->size= size;
1666     ie->flags = flags;
1667
1668     return index;
1669 }
1670
1671 int av_add_index_entry(AVStream *st,
1672                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1673 {
1674     timestamp = wrap_timestamp(st, timestamp);
1675     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1676                               &st->index_entries_allocated_size, pos,
1677                               timestamp, size, distance, flags);
1678 }
1679
1680 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1681                               int64_t wanted_timestamp, int flags)
1682 {
1683     int a, b, m;
1684     int64_t timestamp;
1685
1686     a = - 1;
1687     b = nb_entries;
1688
1689     //optimize appending index entries at the end
1690     if(b && entries[b-1].timestamp < wanted_timestamp)
1691         a= b-1;
1692
1693     while (b - a > 1) {
1694         m = (a + b) >> 1;
1695         timestamp = entries[m].timestamp;
1696         if(timestamp >= wanted_timestamp)
1697             b = m;
1698         if(timestamp <= wanted_timestamp)
1699             a = m;
1700     }
1701     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1702
1703     if(!(flags & AVSEEK_FLAG_ANY)){
1704         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1705             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1706         }
1707     }
1708
1709     if(m == nb_entries)
1710         return -1;
1711     return  m;
1712 }
1713
1714 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1715                               int flags)
1716 {
1717     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1718                                      wanted_timestamp, flags);
1719 }
1720
1721 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1722                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1723 {
1724     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1725     if (stream_index >= 0)
1726         ts = wrap_timestamp(s->streams[stream_index], ts);
1727     return ts;
1728 }
1729
1730 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1731 {
1732     AVInputFormat *avif= s->iformat;
1733     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1734     int64_t ts_min, ts_max, ts;
1735     int index;
1736     int64_t ret;
1737     AVStream *st;
1738
1739     if (stream_index < 0)
1740         return -1;
1741
1742     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1743
1744     ts_max=
1745     ts_min= AV_NOPTS_VALUE;
1746     pos_limit= -1; //gcc falsely says it may be uninitialized
1747
1748     st= s->streams[stream_index];
1749     if(st->index_entries){
1750         AVIndexEntry *e;
1751
1752         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()
1753         index= FFMAX(index, 0);
1754         e= &st->index_entries[index];
1755
1756         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1757             pos_min= e->pos;
1758             ts_min= e->timestamp;
1759             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1760                     pos_min, av_ts2str(ts_min));
1761         }else{
1762             av_assert1(index==0);
1763         }
1764
1765         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1766         av_assert0(index < st->nb_index_entries);
1767         if(index >= 0){
1768             e= &st->index_entries[index];
1769             av_assert1(e->timestamp >= target_ts);
1770             pos_max= e->pos;
1771             ts_max= e->timestamp;
1772             pos_limit= pos_max - e->min_distance;
1773             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1774                     pos_max, pos_limit, av_ts2str(ts_max));
1775         }
1776     }
1777
1778     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1779     if(pos<0)
1780         return -1;
1781
1782     /* do the seek */
1783     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1784         return ret;
1785
1786     ff_read_frame_flush(s);
1787     ff_update_cur_dts(s, st, ts);
1788
1789     return 0;
1790 }
1791
1792 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1793                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1794 {
1795     int64_t step= 1024;
1796     int64_t limit, ts_max;
1797     int64_t filesize = avio_size(s->pb);
1798     int64_t pos_max = filesize - 1;
1799     do{
1800         limit = pos_max;
1801         pos_max = FFMAX(0, (pos_max) - step);
1802         ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1803         step += step;
1804     }while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1805     if (ts_max == AV_NOPTS_VALUE)
1806         return -1;
1807
1808     for(;;){
1809         int64_t tmp_pos = pos_max + 1;
1810         int64_t tmp_ts = ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1811         if(tmp_ts == AV_NOPTS_VALUE)
1812             break;
1813         av_assert0(tmp_pos > pos_max);
1814         ts_max  = tmp_ts;
1815         pos_max = tmp_pos;
1816         if(tmp_pos >= filesize)
1817             break;
1818     }
1819
1820     if (ts)
1821         *ts = ts_max;
1822     if (pos)
1823         *pos = pos_max;
1824
1825     return 0;
1826 }
1827
1828 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1829                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1830                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1831                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1832 {
1833     int64_t pos, ts;
1834     int64_t start_pos;
1835     int no_change;
1836     int ret;
1837
1838     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1839
1840     if(ts_min == AV_NOPTS_VALUE){
1841         pos_min = s->data_offset;
1842         ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1843         if (ts_min == AV_NOPTS_VALUE)
1844             return -1;
1845     }
1846
1847     if(ts_min >= target_ts){
1848         *ts_ret= ts_min;
1849         return pos_min;
1850     }
1851
1852     if(ts_max == AV_NOPTS_VALUE){
1853         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1854             return ret;
1855         pos_limit= pos_max;
1856     }
1857
1858     if(ts_max <= target_ts){
1859         *ts_ret= ts_max;
1860         return pos_max;
1861     }
1862
1863     if(ts_min > ts_max){
1864         return -1;
1865     }else if(ts_min == ts_max){
1866         pos_limit= pos_min;
1867     }
1868
1869     no_change=0;
1870     while (pos_min < pos_limit) {
1871         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1872                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1873         assert(pos_limit <= pos_max);
1874
1875         if(no_change==0){
1876             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1877             // interpolate position (better than dichotomy)
1878             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1879                 + pos_min - approximate_keyframe_distance;
1880         }else if(no_change==1){
1881             // bisection, if interpolation failed to change min or max pos last time
1882             pos = (pos_min + pos_limit)>>1;
1883         }else{
1884             /* linear search if bisection failed, can only happen if there
1885                are very few or no keyframes between min/max */
1886             pos=pos_min;
1887         }
1888         if(pos <= pos_min)
1889             pos= pos_min + 1;
1890         else if(pos > pos_limit)
1891             pos= pos_limit;
1892         start_pos= pos;
1893
1894         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1895         if(pos == pos_max)
1896             no_change++;
1897         else
1898             no_change=0;
1899         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1900                 pos_min, pos, pos_max,
1901                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1902                 pos_limit, start_pos, no_change);
1903         if(ts == AV_NOPTS_VALUE){
1904             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1905             return -1;
1906         }
1907         assert(ts != AV_NOPTS_VALUE);
1908         if (target_ts <= ts) {
1909             pos_limit = start_pos - 1;
1910             pos_max = pos;
1911             ts_max = ts;
1912         }
1913         if (target_ts >= ts) {
1914             pos_min = pos;
1915             ts_min = ts;
1916         }
1917     }
1918
1919     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1920     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1921 #if 0
1922     pos_min = pos;
1923     ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1924     pos_min++;
1925     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1926     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1927             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1928 #endif
1929     *ts_ret= ts;
1930     return pos;
1931 }
1932
1933 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1934     int64_t pos_min, pos_max;
1935
1936     pos_min = s->data_offset;
1937     pos_max = avio_size(s->pb) - 1;
1938
1939     if     (pos < pos_min) pos= pos_min;
1940     else if(pos > pos_max) pos= pos_max;
1941
1942     avio_seek(s->pb, pos, SEEK_SET);
1943
1944     s->io_repositioned = 1;
1945
1946     return 0;
1947 }
1948
1949 static int seek_frame_generic(AVFormatContext *s,
1950                                  int stream_index, int64_t timestamp, int flags)
1951 {
1952     int index;
1953     int64_t ret;
1954     AVStream *st;
1955     AVIndexEntry *ie;
1956
1957     st = s->streams[stream_index];
1958
1959     index = av_index_search_timestamp(st, timestamp, flags);
1960
1961     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1962         return -1;
1963
1964     if(index < 0 || index==st->nb_index_entries-1){
1965         AVPacket pkt;
1966         int nonkey=0;
1967
1968         if(st->nb_index_entries){
1969             av_assert0(st->index_entries);
1970             ie= &st->index_entries[st->nb_index_entries-1];
1971             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1972                 return ret;
1973             ff_update_cur_dts(s, st, ie->timestamp);
1974         }else{
1975             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1976                 return ret;
1977         }
1978         for (;;) {
1979             int read_status;
1980             do{
1981                 read_status = av_read_frame(s, &pkt);
1982             } while (read_status == AVERROR(EAGAIN));
1983             if (read_status < 0)
1984                 break;
1985             av_free_packet(&pkt);
1986             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1987                 if(pkt.flags & AV_PKT_FLAG_KEY)
1988                     break;
1989                 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1990                     av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
1991                     break;
1992                 }
1993             }
1994         }
1995         index = av_index_search_timestamp(st, timestamp, flags);
1996     }
1997     if (index < 0)
1998         return -1;
1999
2000     ff_read_frame_flush(s);
2001     if (s->iformat->read_seek){
2002         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2003             return 0;
2004     }
2005     ie = &st->index_entries[index];
2006     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2007         return ret;
2008     ff_update_cur_dts(s, st, ie->timestamp);
2009
2010     return 0;
2011 }
2012
2013 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2014                                int64_t timestamp, int flags)
2015 {
2016     int ret;
2017     AVStream *st;
2018
2019     if (flags & AVSEEK_FLAG_BYTE) {
2020         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2021             return -1;
2022         ff_read_frame_flush(s);
2023         return seek_frame_byte(s, stream_index, timestamp, flags);
2024     }
2025
2026     if(stream_index < 0){
2027         stream_index= av_find_default_stream_index(s);
2028         if(stream_index < 0)
2029             return -1;
2030
2031         st= s->streams[stream_index];
2032         /* timestamp for default must be expressed in AV_TIME_BASE units */
2033         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2034     }
2035
2036     /* first, we try the format specific seek */
2037     if (s->iformat->read_seek) {
2038         ff_read_frame_flush(s);
2039         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2040     } else
2041         ret = -1;
2042     if (ret >= 0) {
2043         return 0;
2044     }
2045
2046     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2047         ff_read_frame_flush(s);
2048         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2049     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2050         ff_read_frame_flush(s);
2051         return seek_frame_generic(s, stream_index, timestamp, flags);
2052     }
2053     else
2054         return -1;
2055 }
2056
2057 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2058 {
2059     int ret;
2060
2061     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2062         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2063         if ((flags & AVSEEK_FLAG_BACKWARD))
2064             max_ts = timestamp;
2065         else
2066             min_ts = timestamp;
2067         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2068                                   flags & ~AVSEEK_FLAG_BACKWARD);
2069     }
2070
2071     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2072
2073     if (ret >= 0)
2074         ret = avformat_queue_attached_pictures(s);
2075
2076     return ret;
2077 }
2078
2079 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2080 {
2081     if(min_ts > ts || max_ts < ts)
2082         return -1;
2083     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2084         return AVERROR(EINVAL);
2085
2086     if(s->seek2any>0)
2087         flags |= AVSEEK_FLAG_ANY;
2088     flags &= ~AVSEEK_FLAG_BACKWARD;
2089
2090     if (s->iformat->read_seek2) {
2091         int ret;
2092         ff_read_frame_flush(s);
2093
2094         if (stream_index == -1 && s->nb_streams == 1) {
2095             AVRational time_base = s->streams[0]->time_base;
2096             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2097             min_ts = av_rescale_rnd(min_ts, time_base.den,
2098                                     time_base.num * (int64_t)AV_TIME_BASE,
2099                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2100             max_ts = av_rescale_rnd(max_ts, time_base.den,
2101                                     time_base.num * (int64_t)AV_TIME_BASE,
2102                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2103         }
2104
2105         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2106
2107         if (ret >= 0)
2108             ret = avformat_queue_attached_pictures(s);
2109         return ret;
2110     }
2111
2112     if(s->iformat->read_timestamp){
2113         //try to seek via read_timestamp()
2114     }
2115
2116     // Fall back on old API if new is not implemented but old is.
2117     // Note the old API has somewhat different semantics.
2118     if (s->iformat->read_seek || 1) {
2119         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2120         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2121         if (ret<0 && ts != min_ts && max_ts != ts) {
2122             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2123             if (ret >= 0)
2124                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2125         }
2126         return ret;
2127     }
2128
2129     // try some generic seek like seek_frame_generic() but with new ts semantics
2130     return -1; //unreachable
2131 }
2132
2133 /*******************************************************/
2134
2135 /**
2136  * Return TRUE if the stream has accurate duration in any stream.
2137  *
2138  * @return TRUE if the stream has accurate duration for at least one component.
2139  */
2140 static int has_duration(AVFormatContext *ic)
2141 {
2142     int i;
2143     AVStream *st;
2144
2145     for(i = 0;i < ic->nb_streams; i++) {
2146         st = ic->streams[i];
2147         if (st->duration != AV_NOPTS_VALUE)
2148             return 1;
2149     }
2150     if (ic->duration != AV_NOPTS_VALUE)
2151         return 1;
2152     return 0;
2153 }
2154
2155 /**
2156  * Estimate the stream timings from the one of each components.
2157  *
2158  * Also computes the global bitrate if possible.
2159  */
2160 static void update_stream_timings(AVFormatContext *ic)
2161 {
2162     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2163     int64_t duration, duration1, filesize;
2164     int i;
2165     AVStream *st;
2166     AVProgram *p;
2167
2168     start_time = INT64_MAX;
2169     start_time_text = INT64_MAX;
2170     end_time = INT64_MIN;
2171     duration = INT64_MIN;
2172     for(i = 0;i < ic->nb_streams; i++) {
2173         st = ic->streams[i];
2174         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2175             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2176             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2177                 if (start_time1 < start_time_text)
2178                     start_time_text = start_time1;
2179             } else
2180                 start_time = FFMIN(start_time, start_time1);
2181             end_time1 = AV_NOPTS_VALUE;
2182             if (st->duration != AV_NOPTS_VALUE) {
2183                 end_time1 = start_time1
2184                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2185                 end_time = FFMAX(end_time, end_time1);
2186             }
2187             for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2188                 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2189                     p->start_time = start_time1;
2190                 if(p->end_time < end_time1)
2191                     p->end_time = end_time1;
2192             }
2193         }
2194         if (st->duration != AV_NOPTS_VALUE) {
2195             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2196             duration = FFMAX(duration, duration1);
2197         }
2198     }
2199     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2200         start_time = start_time_text;
2201     else if(start_time > start_time_text)
2202         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2203
2204     if (start_time != INT64_MAX) {
2205         ic->start_time = start_time;
2206         if (end_time != INT64_MIN) {
2207             if (ic->nb_programs) {
2208                 for (i=0; i<ic->nb_programs; i++) {
2209                     p = ic->programs[i];
2210                     if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2211                         duration = FFMAX(duration, p->end_time - p->start_time);
2212                 }
2213             } else
2214                 duration = FFMAX(duration, end_time - start_time);
2215         }
2216     }
2217     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2218         ic->duration = duration;
2219     }
2220         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2221             /* compute the bitrate */
2222             double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2223                 (double)ic->duration;
2224             if (bitrate >= 0 && bitrate <= INT_MAX)
2225                 ic->bit_rate = bitrate;
2226         }
2227 }
2228
2229 static void fill_all_stream_timings(AVFormatContext *ic)
2230 {
2231     int i;
2232     AVStream *st;
2233
2234     update_stream_timings(ic);
2235     for(i = 0;i < ic->nb_streams; i++) {
2236         st = ic->streams[i];
2237         if (st->start_time == AV_NOPTS_VALUE) {
2238             if(ic->start_time != AV_NOPTS_VALUE)
2239                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2240             if(ic->duration != AV_NOPTS_VALUE)
2241                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2242         }
2243     }
2244 }
2245
2246 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2247 {
2248     int64_t filesize, duration;
2249     int i, show_warning = 0;
2250     AVStream *st;
2251
2252     /* if bit_rate is already set, we believe it */
2253     if (ic->bit_rate <= 0) {
2254         int bit_rate = 0;
2255         for(i=0;i<ic->nb_streams;i++) {
2256             st = ic->streams[i];
2257             if (st->codec->bit_rate > 0) {
2258                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2259                     bit_rate = 0;
2260                     break;
2261                 }
2262                 bit_rate += st->codec->bit_rate;
2263             }
2264         }
2265         ic->bit_rate = bit_rate;
2266     }
2267
2268     /* if duration is already set, we believe it */
2269     if (ic->duration == AV_NOPTS_VALUE &&
2270         ic->bit_rate != 0) {
2271         filesize = ic->pb ? avio_size(ic->pb) : 0;
2272         if (filesize > 0) {
2273             for(i = 0; i < ic->nb_streams; i++) {
2274                 st = ic->streams[i];
2275                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2276                     && st->duration == AV_NOPTS_VALUE) {
2277                     duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2278                     st->duration = duration;
2279                     show_warning = 1;
2280                 }
2281             }
2282         }
2283     }
2284     if (show_warning)
2285         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2286 }
2287
2288 #define DURATION_MAX_READ_SIZE 250000LL
2289 #define DURATION_MAX_RETRY 4
2290
2291 /* only usable for MPEG-PS streams */
2292 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2293 {
2294     AVPacket pkt1, *pkt = &pkt1;
2295     AVStream *st;
2296     int read_size, i, ret;
2297     int64_t end_time;
2298     int64_t filesize, offset, duration;
2299     int retry=0;
2300
2301     /* flush packet queue */
2302     flush_packet_queue(ic);
2303
2304     for (i=0; i<ic->nb_streams; i++) {
2305         st = ic->streams[i];
2306         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2307             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2308
2309         if (st->parser) {
2310             av_parser_close(st->parser);
2311             st->parser= NULL;
2312         }
2313     }
2314
2315     /* estimate the end time (duration) */
2316     /* XXX: may need to support wrapping */
2317     filesize = ic->pb ? avio_size(ic->pb) : 0;
2318     end_time = AV_NOPTS_VALUE;
2319     do{
2320         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2321         if (offset < 0)
2322             offset = 0;
2323
2324         avio_seek(ic->pb, offset, SEEK_SET);
2325         read_size = 0;
2326         for(;;) {
2327             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2328                 break;
2329
2330             do {
2331                 ret = ff_read_packet(ic, pkt);
2332             } while(ret == AVERROR(EAGAIN));
2333             if (ret != 0)
2334                 break;
2335             read_size += pkt->size;
2336             st = ic->streams[pkt->stream_index];
2337             if (pkt->pts != AV_NOPTS_VALUE &&
2338                 (st->start_time != AV_NOPTS_VALUE ||
2339                  st->first_dts  != AV_NOPTS_VALUE)) {
2340                 duration = end_time = pkt->pts;
2341                 if (st->start_time != AV_NOPTS_VALUE)
2342                     duration -= st->start_time;
2343                 else
2344                     duration -= st->first_dts;
2345                 if (duration > 0) {
2346                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2347                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2348                         st->duration = duration;
2349                     st->info->last_duration = duration;
2350                 }
2351             }
2352             av_free_packet(pkt);
2353         }
2354     }while(   end_time==AV_NOPTS_VALUE
2355            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2356            && ++retry <= DURATION_MAX_RETRY);
2357
2358     fill_all_stream_timings(ic);
2359
2360     avio_seek(ic->pb, old_offset, SEEK_SET);
2361     for (i=0; i<ic->nb_streams; i++) {
2362         st= ic->streams[i];
2363         st->cur_dts= st->first_dts;
2364         st->last_IP_pts = AV_NOPTS_VALUE;
2365     }
2366 }
2367
2368 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2369 {
2370     int64_t file_size;
2371
2372     /* get the file size, if possible */
2373     if (ic->iformat->flags & AVFMT_NOFILE) {
2374         file_size = 0;
2375     } else {
2376         file_size = avio_size(ic->pb);
2377         file_size = FFMAX(0, file_size);
2378     }
2379
2380     if ((!strcmp(ic->iformat->name, "mpeg") ||
2381          !strcmp(ic->iformat->name, "mpegts")) &&
2382         file_size && ic->pb->seekable) {
2383         /* get accurate estimate from the PTSes */
2384         estimate_timings_from_pts(ic, old_offset);
2385         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2386     } else if (has_duration(ic)) {
2387         /* at least one component has timings - we use them for all
2388            the components */
2389         fill_all_stream_timings(ic);
2390         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2391     } else {
2392         /* less precise: use bitrate info */
2393         estimate_timings_from_bit_rate(ic);
2394         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2395     }
2396     update_stream_timings(ic);
2397
2398     {
2399         int i;
2400         AVStream av_unused *st;
2401         for(i = 0;i < ic->nb_streams; i++) {
2402             st = ic->streams[i];
2403             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2404                     (double) st->start_time / AV_TIME_BASE,
2405                     (double) st->duration   / AV_TIME_BASE);
2406         }
2407         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2408                 (double) ic->start_time / AV_TIME_BASE,
2409                 (double) ic->duration   / AV_TIME_BASE,
2410                 ic->bit_rate / 1000);
2411     }
2412 }
2413
2414 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2415 {
2416     AVCodecContext *avctx = st->codec;
2417
2418 #define FAIL(errmsg) do {                                         \
2419         if (errmsg_ptr)                                           \
2420             *errmsg_ptr = errmsg;                                 \
2421         return 0;                                                 \
2422     } while (0)
2423
2424     switch (avctx->codec_type) {
2425     case AVMEDIA_TYPE_AUDIO:
2426         if (!avctx->frame_size && determinable_frame_size(avctx))
2427             FAIL("unspecified frame size");
2428         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2429             FAIL("unspecified sample format");
2430         if (!avctx->sample_rate)
2431             FAIL("unspecified sample rate");
2432         if (!avctx->channels)
2433             FAIL("unspecified number of channels");
2434         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2435             FAIL("no decodable DTS frames");
2436         break;
2437     case AVMEDIA_TYPE_VIDEO:
2438         if (!avctx->width)
2439             FAIL("unspecified size");
2440         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2441             FAIL("unspecified pixel format");
2442         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2443             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2444                 FAIL("no frame in rv30/40 and no sar");
2445         break;
2446     case AVMEDIA_TYPE_SUBTITLE:
2447         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2448             FAIL("unspecified size");
2449         break;
2450     case AVMEDIA_TYPE_DATA:
2451         if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2452     }
2453
2454     if (avctx->codec_id == AV_CODEC_ID_NONE)
2455         FAIL("unknown codec");
2456     return 1;
2457 }
2458
2459 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2460 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
2461 {
2462     const AVCodec *codec;
2463     int got_picture = 1, ret = 0;
2464     AVFrame *frame = av_frame_alloc();
2465     AVSubtitle subtitle;
2466     AVPacket pkt = *avpkt;
2467
2468     if (!frame)
2469         return AVERROR(ENOMEM);
2470
2471     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2472         AVDictionary *thread_opt = NULL;
2473
2474         codec = find_decoder(s, st, st->codec->codec_id);
2475
2476         if (!codec) {
2477             st->info->found_decoder = -1;
2478             ret = -1;
2479             goto fail;
2480         }
2481
2482         /* force thread count to 1 since the h264 decoder will not extract SPS
2483          *  and PPS to extradata during multi-threaded decoding */
2484         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2485         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2486         if (!options)
2487             av_dict_free(&thread_opt);
2488         if (ret < 0) {
2489             st->info->found_decoder = -1;
2490             goto fail;
2491         }
2492         st->info->found_decoder = 1;
2493     } else if (!st->info->found_decoder)
2494         st->info->found_decoder = 1;
2495
2496     if (st->info->found_decoder < 0) {
2497         ret = -1;
2498         goto fail;
2499     }
2500
2501     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2502            ret >= 0 &&
2503            (!has_codec_parameters(st, NULL)   ||
2504            !has_decode_delay_been_guessed(st) ||
2505            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2506         got_picture = 0;
2507         switch(st->codec->codec_type) {
2508         case AVMEDIA_TYPE_VIDEO:
2509             ret = avcodec_decode_video2(st->codec, frame,
2510                                         &got_picture, &pkt);
2511             break;
2512         case AVMEDIA_TYPE_AUDIO:
2513             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2514             break;
2515         case AVMEDIA_TYPE_SUBTITLE:
2516             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2517                                            &got_picture, &pkt);
2518             ret = pkt.size;
2519             break;
2520         default:
2521             break;
2522         }
2523         if (ret >= 0) {
2524             if (got_picture)
2525                 st->nb_decoded_frames++;
2526             pkt.data += ret;
2527             pkt.size -= ret;
2528             ret       = got_picture;
2529         }
2530     }
2531
2532     if(!pkt.data && !got_picture)
2533         ret = -1;
2534
2535 fail:
2536     av_frame_free(&frame);
2537     return ret;
2538 }
2539
2540 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2541 {
2542     while (tags->id != AV_CODEC_ID_NONE) {
2543         if (tags->id == id)
2544             return tags->tag;
2545         tags++;
2546     }
2547     return 0;
2548 }
2549
2550 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2551 {
2552     int i;
2553     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2554         if(tag == tags[i].tag)
2555             return tags[i].id;
2556     }
2557     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2558         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2559             return tags[i].id;
2560     }
2561     return AV_CODEC_ID_NONE;
2562 }
2563
2564 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2565 {
2566     if (flt) {
2567         switch (bps) {
2568         case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2569         case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2570         default: return AV_CODEC_ID_NONE;
2571         }
2572     } else {
2573         bps  += 7;
2574         bps >>= 3;
2575         if (sflags & (1 << (bps - 1))) {
2576             switch (bps) {
2577             case 1:  return AV_CODEC_ID_PCM_S8;
2578             case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2579             case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2580             case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2581             default: return AV_CODEC_ID_NONE;
2582             }
2583         } else {
2584             switch (bps) {
2585             case 1:  return AV_CODEC_ID_PCM_U8;
2586             case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2587             case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2588             case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2589             default: return AV_CODEC_ID_NONE;
2590             }
2591         }
2592     }
2593 }
2594
2595 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2596 {
2597     unsigned int tag;
2598     if (!av_codec_get_tag2(tags, id, &tag))
2599         return 0;
2600     return tag;
2601 }
2602
2603 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2604                       unsigned int *tag)
2605 {
2606     int i;
2607     for(i=0; tags && tags[i]; i++){
2608         const AVCodecTag *codec_tags = tags[i];
2609         while (codec_tags->id != AV_CODEC_ID_NONE) {
2610             if (codec_tags->id == id) {
2611                 *tag = codec_tags->tag;
2612                 return 1;
2613             }
2614             codec_tags++;
2615         }
2616     }
2617     return 0;
2618 }
2619
2620 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2621 {
2622     int i;
2623     for(i=0; tags && tags[i]; i++){
2624         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2625         if(id!=AV_CODEC_ID_NONE) return id;
2626     }
2627     return AV_CODEC_ID_NONE;
2628 }
2629
2630 static void compute_chapters_end(AVFormatContext *s)
2631 {
2632     unsigned int i, j;
2633     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2634
2635     for (i = 0; i < s->nb_chapters; i++)
2636         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2637             AVChapter *ch = s->chapters[i];
2638             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2639                                      : INT64_MAX;
2640
2641             for (j = 0; j < s->nb_chapters; j++) {
2642                 AVChapter *ch1 = s->chapters[j];
2643                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2644                 if (j != i && next_start > ch->start && next_start < end)
2645                     end = next_start;
2646             }
2647             ch->end = (end == INT64_MAX) ? ch->start : end;
2648         }
2649 }
2650
2651 static int get_std_framerate(int i){
2652     if(i<60*12) return (i+1)*1001;
2653     else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2654 }
2655
2656 /*
2657  * Is the time base unreliable.
2658  * This is a heuristic to balance between quick acceptance of the values in
2659  * the headers vs. some extra checks.
2660  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2661  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2662  * And there are "variable" fps files this needs to detect as well.
2663  */
2664 static int tb_unreliable(AVCodecContext *c){
2665     if(   c->time_base.den >= 101L*c->time_base.num
2666        || c->time_base.den <    5L*c->time_base.num
2667 /*       || c->codec_tag == AV_RL32("DIVX")
2668        || c->codec_tag == AV_RL32("XVID")*/
2669        || c->codec_tag == AV_RL32("mp4v")
2670        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2671        || c->codec_id == AV_CODEC_ID_H264
2672        )
2673         return 1;
2674     return 0;
2675 }
2676
2677 #if FF_API_FORMAT_PARAMETERS
2678 int av_find_stream_info(AVFormatContext *ic)
2679 {
2680     return avformat_find_stream_info(ic, NULL);
2681 }
2682 #endif
2683
2684 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2685 {
2686     int ret;
2687
2688     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2689         avctx->extradata_size = 0;
2690         return AVERROR(EINVAL);
2691     }
2692     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2693     if (avctx->extradata) {
2694         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2695         avctx->extradata_size = size;
2696         ret = 0;
2697     } else {
2698         avctx->extradata_size = 0;
2699         ret = AVERROR(ENOMEM);
2700     }
2701     return ret;
2702 }
2703
2704 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2705 {
2706     int i, j;
2707     int64_t last = st->info->last_dts;
2708
2709     if(   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2710        && ts - (uint64_t)last < INT64_MAX){
2711         double dts= (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2712         int64_t duration= ts - last;
2713
2714         if (!st->info->duration_error)
2715             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2716         if (!st->info->duration_error)
2717             return AVERROR(ENOMEM);
2718
2719 //         if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2720 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2721         for (i=0; i<MAX_STD_TIMEBASES; i++) {
2722             if (st->info->duration_error[0][1][i] < 1e10) {
2723                 int framerate= get_std_framerate(i);
2724                 double sdts= dts*framerate/(1001*12);
2725                 for(j=0; j<2; j++){
2726                     int64_t ticks= llrint(sdts+j*0.5);
2727                     double error= sdts - ticks + j*0.5;
2728                     st->info->duration_error[j][0][i] += error;
2729                     st->info->duration_error[j][1][i] += error*error;
2730                 }
2731             }
2732         }
2733         st->info->duration_count++;
2734         st->info->rfps_duration_sum += duration;
2735
2736         if (st->info->duration_count % 10 == 0) {
2737             int n = st->info->duration_count;
2738             for (i=0; i<MAX_STD_TIMEBASES; i++) {
2739                 if (st->info->duration_error[0][1][i] < 1e10) {
2740                     double a0     = st->info->duration_error[0][0][i] / n;
2741                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2742                     double a1     = st->info->duration_error[1][0][i] / n;
2743                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2744                     if (error0 > 0.04 && error1 > 0.04) {
2745                         st->info->duration_error[0][1][i] = 2e10;
2746                         st->info->duration_error[1][1][i] = 2e10;
2747                     }
2748                 }
2749             }
2750         }
2751
2752         // ignore the first 4 values, they might have some random jitter
2753         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2754             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2755     }
2756     if (ts != AV_NOPTS_VALUE)
2757         st->info->last_dts = ts;
2758
2759     return 0;
2760 }
2761
2762 void ff_rfps_calculate(AVFormatContext *ic)
2763 {
2764     int i, j;
2765
2766     for (i = 0; i<ic->nb_streams; i++) {
2767         AVStream *st = ic->streams[i];
2768
2769         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2770             continue;
2771         // the check for tb_unreliable() is not completely correct, since this is not about handling
2772         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2773         // ipmovie.c produces.
2774         if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num)
2775             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);
2776         if (st->info->duration_count>1 && !st->r_frame_rate.num
2777             && tb_unreliable(st->codec)) {
2778             int num = 0;
2779             double best_error= 0.01;
2780
2781             for (j=0; j<MAX_STD_TIMEBASES; j++) {
2782                 int k;
2783
2784                 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2785                     continue;
2786                 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2787                     continue;
2788
2789                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2790                     continue;
2791
2792                 for(k=0; k<2; k++){
2793                     int n= st->info->duration_count;
2794                     double a= st->info->duration_error[k][0][j] / n;
2795                     double error= st->info->duration_error[k][1][j]/n - a*a;
2796
2797                     if(error < best_error && best_error> 0.000000001){
2798                         best_error= error;
2799                         num = get_std_framerate(j);
2800                     }
2801                     if(error < 0.02)
2802                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2803                 }
2804             }
2805             // do not increase frame rate by more than 1 % in order to match a standard rate.
2806             if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2807                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2808         }
2809
2810         av_freep(&st->info->duration_error);
2811         st->info->last_dts = AV_NOPTS_VALUE;
2812         st->info->duration_count = 0;
2813         st->info->rfps_duration_sum = 0;
2814     }
2815 }
2816
2817 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2818 {
2819     int i, count, ret = 0, j;
2820     int64_t read_size;
2821     AVStream *st;
2822     AVPacket pkt1, *pkt;
2823     int64_t old_offset = avio_tell(ic->pb);
2824     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2825     int flush_codecs = ic->probesize > 0;
2826
2827     if(ic->pb)
2828         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2829                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2830
2831     for(i=0;i<ic->nb_streams;i++) {
2832         const AVCodec *codec;
2833         AVDictionary *thread_opt = NULL;
2834         st = ic->streams[i];
2835
2836         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2837             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2838 /*            if(!st->time_base.num)
2839                 st->time_base= */
2840             if(!st->codec->time_base.num)
2841                 st->codec->time_base= st->time_base;
2842         }
2843         //only for the split stuff
2844         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2845             st->parser = av_parser_init(st->codec->codec_id);
2846             if(st->parser){
2847                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2848                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2849                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2850                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2851                 }
2852             } else if (st->need_parsing) {
2853                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2854                        "%s, packets or times may be invalid.\n",
2855                        avcodec_get_name(st->codec->codec_id));
2856             }
2857         }
2858         codec = find_decoder(ic, st, st->codec->codec_id);
2859
2860         /* force thread count to 1 since the h264 decoder will not extract SPS
2861          *  and PPS to extradata during multi-threaded decoding */
2862         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2863
2864         /* Ensure that subtitle_header is properly set. */
2865         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2866             && codec && !st->codec->codec) {
2867             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2868                 av_log(ic, AV_LOG_WARNING, "Failed to open codec in av_find_stream_info\n");
2869         }
2870
2871         //try to just open decoders, in case this is enough to get parameters
2872         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2873             if (codec && !st->codec->codec)
2874                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2875                     av_log(ic, AV_LOG_WARNING, "Failed to open codec in av_find_stream_info\n");
2876         }
2877         if (!options)
2878             av_dict_free(&thread_opt);
2879     }
2880
2881     for (i=0; i<ic->nb_streams; i++) {
2882 #if FF_API_R_FRAME_RATE
2883         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2884 #endif
2885         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2886         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2887     }
2888
2889     count = 0;
2890     read_size = 0;
2891     for(;;) {
2892         if (ff_check_interrupt(&ic->interrupt_callback)){
2893             ret= AVERROR_EXIT;
2894             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2895             break;
2896         }
2897
2898         /* check if one codec still needs to be handled */
2899         for(i=0;i<ic->nb_streams;i++) {
2900             int fps_analyze_framecount = 20;
2901
2902             st = ic->streams[i];
2903             if (!has_codec_parameters(st, NULL))
2904                 break;
2905             /* if the timebase is coarse (like the usual millisecond precision
2906                of mkv), we need to analyze more frames to reliably arrive at
2907                the correct fps */
2908             if (av_q2d(st->time_base) > 0.0005)
2909                 fps_analyze_framecount *= 2;
2910             if (ic->fps_probe_size >= 0)
2911                 fps_analyze_framecount = ic->fps_probe_size;
2912             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2913                 fps_analyze_framecount = 0;
2914             /* variable fps and no guess at the real fps */
2915             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2916                && st->info->duration_count < fps_analyze_framecount
2917                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2918                 break;
2919             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2920                 break;
2921             if (st->first_dts == AV_NOPTS_VALUE &&
2922                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2923                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2924                 break;
2925         }
2926         if (i == ic->nb_streams) {
2927             /* NOTE: if the format has no header, then we need to read
2928                some packets to get most of the streams, so we cannot
2929                stop here */
2930             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2931                 /* if we found the info for all the codecs, we can stop */
2932                 ret = count;
2933                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2934                 flush_codecs = 0;
2935                 break;
2936             }
2937         }
2938         /* we did not get all the codec info, but we read too much data */
2939         if (read_size >= ic->probesize) {
2940             ret = count;
2941             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2942             for (i = 0; i < ic->nb_streams; i++)
2943                 if (!ic->streams[i]->r_frame_rate.num &&
2944                     ic->streams[i]->info->duration_count <= 1 &&
2945                     strcmp(ic->iformat->name, "image2"))
2946                     av_log(ic, AV_LOG_WARNING,
2947                            "Stream #%d: not enough frames to estimate rate; "
2948                            "consider increasing probesize\n", i);
2949             break;
2950         }
2951
2952         /* NOTE: a new stream can be added there if no header in file
2953            (AVFMTCTX_NOHEADER) */
2954         ret = read_frame_internal(ic, &pkt1);
2955         if (ret == AVERROR(EAGAIN))
2956             continue;
2957
2958         if (ret < 0) {
2959             /* EOF or error*/
2960             break;
2961         }
2962
2963         if (ic->flags & AVFMT_FLAG_NOBUFFER)
2964             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2965         {
2966             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2967                                 &ic->packet_buffer_end);
2968             if (!pkt) {
2969                 ret = AVERROR(ENOMEM);
2970                 goto find_stream_info_err;
2971             }
2972             if ((ret = av_dup_packet(pkt)) < 0)
2973                 goto find_stream_info_err;
2974         }
2975
2976         st = ic->streams[pkt->stream_index];
2977         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2978             read_size += pkt->size;
2979
2980         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2981             /* check for non-increasing dts */
2982             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2983                 st->info->fps_last_dts >= pkt->dts) {
2984                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2985                        "packet %d with DTS %"PRId64", packet %d with DTS "
2986                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2987                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2988                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2989             }
2990             /* check for a discontinuity in dts - if the difference in dts
2991              * is more than 1000 times the average packet duration in the sequence,
2992              * we treat it as a discontinuity */
2993             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2994                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2995                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2996                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2997                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2998                        "packet %d with DTS %"PRId64", packet %d with DTS "
2999                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
3000                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
3001                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
3002             }
3003
3004             /* update stored dts values */
3005             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3006                 st->info->fps_first_dts     = pkt->dts;
3007                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3008             }
3009             st->info->fps_last_dts = pkt->dts;
3010             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3011         }
3012         if (st->codec_info_nb_frames>1) {
3013             int64_t t=0;
3014             if (st->time_base.den > 0)
3015                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3016             if (st->avg_frame_rate.num > 0)
3017                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3018
3019             if (   t==0
3020                 && st->codec_info_nb_frames>30
3021                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3022                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3023                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3024
3025             if (t >= ic->max_analyze_duration) {
3026                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
3027                 break;
3028             }
3029             if (pkt->duration) {
3030                 st->info->codec_info_duration        += pkt->duration;
3031                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
3032             }
3033         }
3034 #if FF_API_R_FRAME_RATE
3035         ff_rfps_add_frame(ic, st, pkt->dts);
3036 #endif
3037         if(st->parser && st->parser->parser->split && !st->codec->extradata){
3038             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
3039             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3040                 if (ff_alloc_extradata(st->codec, i))
3041                     return AVERROR(ENOMEM);
3042                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
3043             }
3044         }
3045
3046         /* if still no information, we try to open the codec and to
3047            decompress the frame. We try to avoid that in most cases as
3048            it takes longer and uses more memory. For MPEG-4, we need to
3049            decompress for QuickTime.
3050
3051            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3052            least one frame of codec data, this makes sure the codec initializes
3053            the channel configuration and does not only trust the values from the container.
3054         */
3055         try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
3056
3057         st->codec_info_nb_frames++;
3058         count++;
3059     }
3060
3061     if (flush_codecs) {
3062         AVPacket empty_pkt = { 0 };
3063         int err = 0;
3064         av_init_packet(&empty_pkt);
3065
3066         for(i=0;i<ic->nb_streams;i++) {
3067
3068             st = ic->streams[i];
3069
3070             /* flush the decoders */
3071             if (st->info->found_decoder == 1) {
3072                 do {
3073                     err = try_decode_frame(ic, st, &empty_pkt,
3074                                             (options && i < orig_nb_streams) ?
3075                                             &options[i] : NULL);
3076                 } while (err > 0 && !has_codec_parameters(st, NULL));
3077
3078                 if (err < 0) {
3079                     av_log(ic, AV_LOG_INFO,
3080                         "decoding for stream %d failed\n", st->index);
3081                 }
3082             }
3083         }
3084     }
3085
3086     // close codecs which were opened in try_decode_frame()
3087     for(i=0;i<ic->nb_streams;i++) {
3088         st = ic->streams[i];
3089         avcodec_close(st->codec);
3090     }
3091
3092     ff_rfps_calculate(ic);
3093
3094     for(i=0;i<ic->nb_streams;i++) {
3095         st = ic->streams[i];
3096         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3097             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3098                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3099                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3100                     st->codec->codec_tag= tag;
3101             }
3102
3103             /* estimate average framerate if not set by demuxer */
3104             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3105                 int      best_fps = 0;
3106                 double best_error = 0.01;
3107
3108                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3109                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3110                     st->info->codec_info_duration        < 0)
3111                     continue;
3112                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3113                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3114                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3115
3116                 /* round guessed framerate to a "standard" framerate if it's
3117                  * within 1% of the original estimate*/
3118                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3119                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
3120                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3121
3122                     if (error < best_error) {
3123                         best_error = error;
3124                         best_fps   = std_fps.num;
3125                     }
3126                 }
3127                 if (best_fps) {
3128                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3129                               best_fps, 12*1001, INT_MAX);
3130                 }
3131             }
3132
3133             if (!st->r_frame_rate.num){
3134                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3135                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3136                     st->r_frame_rate.num = st->codec->time_base.den;
3137                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3138                 }else{
3139                     st->r_frame_rate.num = st->time_base.den;
3140                     st->r_frame_rate.den = st->time_base.num;
3141                 }
3142             }
3143         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3144             if(!st->codec->bits_per_coded_sample)
3145                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3146             // set stream disposition based on audio service type
3147             switch (st->codec->audio_service_type) {
3148             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3149                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3150             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3151                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3152             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3153                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3154             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3155                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3156             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3157                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3158             }
3159         }
3160     }
3161
3162     if(ic->probesize)
3163     estimate_timings(ic, old_offset);
3164
3165     if (ret >= 0 && ic->nb_streams)
3166         ret = -1; /* we could not have all the codec parameters before EOF */
3167     for(i=0;i<ic->nb_streams;i++) {
3168         const char *errmsg;
3169         st = ic->streams[i];
3170         if (!has_codec_parameters(st, &errmsg)) {
3171             char buf[256];
3172             avcodec_string(buf, sizeof(buf), st->codec, 0);
3173             av_log(ic, AV_LOG_WARNING,
3174                    "Could not find codec parameters for stream %d (%s): %s\n"
3175                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3176                    i, buf, errmsg);
3177         } else {
3178             ret = 0;
3179         }
3180     }
3181
3182     compute_chapters_end(ic);
3183
3184  find_stream_info_err:
3185     for (i=0; i < ic->nb_streams; i++) {
3186         st = ic->streams[i];
3187         if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3188             ic->streams[i]->codec->thread_count = 0;
3189         if (st->info)
3190             av_freep(&st->info->duration_error);
3191         av_freep(&ic->streams[i]->info);
3192     }
3193     if(ic->pb)
3194         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3195                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3196     return ret;
3197 }
3198
3199 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3200 {
3201     int i, j;
3202
3203     for (i = 0; i < ic->nb_programs; i++) {
3204         if (ic->programs[i] == last) {
3205             last = NULL;
3206         } else {
3207             if (!last)
3208                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3209                     if (ic->programs[i]->stream_index[j] == s)
3210                         return ic->programs[i];
3211         }
3212     }
3213     return NULL;
3214 }
3215
3216 int av_find_best_stream(AVFormatContext *ic,
3217                         enum AVMediaType type,
3218                         int wanted_stream_nb,
3219                         int related_stream,
3220                         AVCodec **decoder_ret,
3221                         int flags)
3222 {
3223     int i, nb_streams = ic->nb_streams;
3224     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3225     unsigned *program = NULL;
3226     AVCodec *decoder = NULL, *best_decoder = NULL;
3227
3228     if (related_stream >= 0 && wanted_stream_nb < 0) {
3229         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3230         if (p) {
3231             program = p->stream_index;
3232             nb_streams = p->nb_stream_indexes;
3233         }
3234     }
3235     for (i = 0; i < nb_streams; i++) {
3236         int real_stream_index = program ? program[i] : i;
3237         AVStream *st = ic->streams[real_stream_index];
3238         AVCodecContext *avctx = st->codec;
3239         if (avctx->codec_type != type)
3240             continue;
3241         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3242             continue;
3243         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3244             continue;
3245         if (decoder_ret) {
3246             decoder = find_decoder(ic, st, st->codec->codec_id);
3247             if (!decoder) {
3248                 if (ret < 0)
3249                     ret = AVERROR_DECODER_NOT_FOUND;
3250                 continue;
3251             }
3252         }
3253         count = st->codec_info_nb_frames;
3254         bitrate = avctx->bit_rate;
3255         multiframe = FFMIN(5, count);
3256         if ((best_multiframe >  multiframe) ||
3257             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3258             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3259             continue;
3260         best_count = count;
3261         best_bitrate = bitrate;
3262         best_multiframe = multiframe;
3263         ret = real_stream_index;
3264         best_decoder = decoder;
3265         if (program && i == nb_streams - 1 && ret < 0) {
3266             program = NULL;
3267             nb_streams = ic->nb_streams;
3268             i = 0; /* no related stream found, try again with everything */
3269         }
3270     }
3271     if (decoder_ret)
3272         *decoder_ret = best_decoder;
3273     return ret;
3274 }
3275
3276 /*******************************************************/
3277
3278 int av_read_play(AVFormatContext *s)
3279 {
3280     if (s->iformat->read_play)
3281         return s->iformat->read_play(s);
3282     if (s->pb)
3283         return avio_pause(s->pb, 0);
3284     return AVERROR(ENOSYS);
3285 }
3286
3287 int av_read_pause(AVFormatContext *s)
3288 {
3289     if (s->iformat->read_pause)
3290         return s->iformat->read_pause(s);
3291     if (s->pb)
3292         return avio_pause(s->pb, 1);
3293     return AVERROR(ENOSYS);
3294 }
3295
3296 void ff_free_stream(AVFormatContext *s, AVStream *st){
3297     av_assert0(s->nb_streams>0);
3298     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3299
3300     if (st->parser) {
3301         av_parser_close(st->parser);
3302     }
3303     if (st->attached_pic.data)
3304         av_free_packet(&st->attached_pic);
3305     av_dict_free(&st->metadata);
3306     av_freep(&st->probe_data.buf);
3307     av_freep(&st->index_entries);
3308     av_freep(&st->codec->extradata);
3309     av_freep(&st->codec->subtitle_header);
3310     av_freep(&st->codec);
3311     av_freep(&st->priv_data);
3312     if (st->info)
3313         av_freep(&st->info->duration_error);
3314     av_freep(&st->info);
3315     av_freep(&s->streams[ --s->nb_streams ]);
3316 }
3317
3318 void avformat_free_context(AVFormatContext *s)
3319 {
3320     int i;
3321
3322     if (!s)
3323         return;
3324
3325     av_opt_free(s);
3326     if (s->iformat && s->iformat->priv_class && s->priv_data)
3327         av_opt_free(s->priv_data);
3328
3329     for(i=s->nb_streams-1; i>=0; i--) {
3330         ff_free_stream(s, s->streams[i]);
3331     }
3332     for(i=s->nb_programs-1; i>=0; i--) {
3333         av_dict_free(&s->programs[i]->metadata);
3334         av_freep(&s->programs[i]->stream_index);
3335         av_freep(&s->programs[i]);
3336     }
3337     av_freep(&s->programs);
3338     av_freep(&s->priv_data);
3339     while(s->nb_chapters--) {
3340         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3341         av_freep(&s->chapters[s->nb_chapters]);
3342     }
3343     av_freep(&s->chapters);
3344     av_dict_free(&s->metadata);
3345     av_freep(&s->streams);
3346     av_free(s);
3347 }
3348
3349 #if FF_API_CLOSE_INPUT_FILE
3350 void av_close_input_file(AVFormatContext *s)
3351 {
3352     avformat_close_input(&s);
3353 }
3354 #endif
3355
3356 void avformat_close_input(AVFormatContext **ps)
3357 {
3358     AVFormatContext *s;
3359     AVIOContext *pb;
3360
3361     if (!ps || !*ps)
3362         return;
3363
3364     s = *ps;
3365     pb = s->pb;
3366
3367     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3368         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3369         pb = NULL;
3370
3371     flush_packet_queue(s);
3372
3373     if (s->iformat) {
3374         if (s->iformat->read_close)
3375             s->iformat->read_close(s);
3376     }
3377
3378     avformat_free_context(s);
3379
3380     *ps = NULL;
3381
3382     avio_close(pb);
3383 }
3384
3385 #if FF_API_NEW_STREAM
3386 AVStream *av_new_stream(AVFormatContext *s, int id)
3387 {
3388     AVStream *st = avformat_new_stream(s, NULL);
3389     if (st)
3390         st->id = id;
3391     return st;
3392 }
3393 #endif
3394
3395 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3396 {
3397     AVStream *st;
3398     int i;
3399     AVStream **streams;
3400
3401     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3402         return NULL;
3403     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3404     if (!streams)
3405         return NULL;
3406     s->streams = streams;
3407
3408     st = av_mallocz(sizeof(AVStream));
3409     if (!st)
3410         return NULL;
3411     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3412         av_free(st);
3413         return NULL;
3414     }
3415     st->info->last_dts = AV_NOPTS_VALUE;
3416
3417     st->codec = avcodec_alloc_context3(c);
3418     if (s->iformat) {
3419         /* no default bitrate if decoding */
3420         st->codec->bit_rate = 0;
3421     }
3422     st->index = s->nb_streams;
3423     st->start_time = AV_NOPTS_VALUE;
3424     st->duration = AV_NOPTS_VALUE;
3425         /* we set the current DTS to 0 so that formats without any timestamps
3426            but durations get some timestamps, formats with some unknown
3427            timestamps have their first few packets buffered and the
3428            timestamps corrected before they are returned to the user */
3429     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3430     st->first_dts = AV_NOPTS_VALUE;
3431     st->probe_packets = MAX_PROBE_PACKETS;
3432     st->pts_wrap_reference = AV_NOPTS_VALUE;
3433     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3434
3435     /* default pts setting is MPEG-like */
3436     avpriv_set_pts_info(st, 33, 1, 90000);
3437     st->last_IP_pts = AV_NOPTS_VALUE;
3438     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3439         st->pts_buffer[i]= AV_NOPTS_VALUE;
3440
3441     st->sample_aspect_ratio = (AVRational){0,1};
3442
3443 #if FF_API_R_FRAME_RATE
3444     st->info->last_dts      = AV_NOPTS_VALUE;
3445 #endif
3446     st->info->fps_first_dts = AV_NOPTS_VALUE;
3447     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3448
3449     s->streams[s->nb_streams++] = st;
3450     return st;
3451 }
3452
3453 AVProgram *av_new_program(AVFormatContext *ac, int id)
3454 {
3455     AVProgram *program=NULL;
3456     int i;
3457
3458     av_dlog(ac, "new_program: id=0x%04x\n", id);
3459
3460     for(i=0; i<ac->nb_programs; i++)
3461         if(ac->programs[i]->id == id)
3462             program = ac->programs[i];
3463
3464     if(!program){
3465         program = av_mallocz(sizeof(AVProgram));
3466         if (!program)
3467             return NULL;
3468         dynarray_add(&ac->programs, &ac->nb_programs, program);
3469         program->discard = AVDISCARD_NONE;
3470     }
3471     program->id = id;
3472     program->pts_wrap_reference = AV_NOPTS_VALUE;
3473     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3474
3475     program->start_time =
3476     program->end_time   = AV_NOPTS_VALUE;
3477
3478     return program;
3479 }
3480
3481 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3482 {
3483     AVChapter *chapter = NULL;
3484     int i;
3485
3486     for(i=0; i<s->nb_chapters; i++)
3487         if(s->chapters[i]->id == id)
3488             chapter = s->chapters[i];
3489
3490     if(!chapter){
3491         chapter= av_mallocz(sizeof(AVChapter));
3492         if(!chapter)
3493             return NULL;
3494         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3495     }
3496     av_dict_set(&chapter->metadata, "title", title, 0);
3497     chapter->id    = id;
3498     chapter->time_base= time_base;
3499     chapter->start = start;
3500     chapter->end   = end;
3501
3502     return chapter;
3503 }
3504
3505 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3506 {
3507     int i, j;
3508     AVProgram *program=NULL;
3509     void *tmp;
3510
3511     if (idx >= ac->nb_streams) {
3512         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3513         return;
3514     }
3515
3516     for(i=0; i<ac->nb_programs; i++){
3517         if(ac->programs[i]->id != progid)
3518             continue;
3519         program = ac->programs[i];
3520         for(j=0; j<program->nb_stream_indexes; j++)
3521             if(program->stream_index[j] == idx)
3522                 return;
3523
3524         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3525         if(!tmp)
3526             return;
3527         program->stream_index = tmp;
3528         program->stream_index[program->nb_stream_indexes++] = idx;
3529         return;
3530     }
3531 }
3532
3533 static void print_fps(double d, const char *postfix){
3534     uint64_t v= lrintf(d*100);
3535     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3536     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3537     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3538 }
3539
3540 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3541 {
3542     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3543         AVDictionaryEntry *tag=NULL;
3544
3545         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3546         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3547             if(strcmp("language", tag->key)){
3548                 const char *p = tag->value;
3549                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3550                 while(*p) {
3551                     char tmp[256];
3552                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3553                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3554                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3555                     p += len;
3556                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3557                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3558                     if (*p) p++;
3559                 }
3560                 av_log(ctx, AV_LOG_INFO, "\n");
3561             }
3562         }
3563     }
3564 }
3565
3566 /* "user interface" functions */
3567 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3568 {
3569     char buf[256];
3570     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3571     AVStream *st = ic->streams[i];
3572     int g = av_gcd(st->time_base.num, st->time_base.den);
3573     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3574     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3575     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3576     /* the pid is an important information, so we display it */
3577     /* XXX: add a generic system */
3578     if (flags & AVFMT_SHOW_IDS)
3579         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3580     if (lang)
3581         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3582     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3583     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3584     if (st->sample_aspect_ratio.num && // default
3585         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3586         AVRational display_aspect_ratio;
3587         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3588                   st->codec->width*st->sample_aspect_ratio.num,
3589                   st->codec->height*st->sample_aspect_ratio.den,
3590                   1024*1024);
3591         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3592                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3593                  display_aspect_ratio.num, display_aspect_ratio.den);
3594     }
3595     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3596         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3597             print_fps(av_q2d(st->avg_frame_rate), "fps");
3598 #if FF_API_R_FRAME_RATE
3599         if(st->r_frame_rate.den && st->r_frame_rate.num)
3600             print_fps(av_q2d(st->r_frame_rate), "tbr");
3601 #endif
3602         if(st->time_base.den && st->time_base.num)
3603             print_fps(1/av_q2d(st->time_base), "tbn");
3604         if(st->codec->time_base.den && st->codec->time_base.num)
3605             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3606     }
3607     if (st->disposition & AV_DISPOSITION_DEFAULT)
3608         av_log(NULL, AV_LOG_INFO, " (default)");
3609     if (st->disposition & AV_DISPOSITION_DUB)
3610         av_log(NULL, AV_LOG_INFO, " (dub)");
3611     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3612         av_log(NULL, AV_LOG_INFO, " (original)");
3613     if (st->disposition & AV_DISPOSITION_COMMENT)
3614         av_log(NULL, AV_LOG_INFO, " (comment)");
3615     if (st->disposition & AV_DISPOSITION_LYRICS)
3616         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3617     if (st->disposition & AV_DISPOSITION_KARAOKE)
3618         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3619     if (st->disposition & AV_DISPOSITION_FORCED)
3620         av_log(NULL, AV_LOG_INFO, " (forced)");
3621     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3622         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3623     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3624         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3625     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3626         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3627     av_log(NULL, AV_LOG_INFO, "\n");
3628     dump_metadata(NULL, st->metadata, "    ");
3629 }
3630
3631 void av_dump_format(AVFormatContext *ic,
3632                     int index,
3633                     const char *url,
3634                     int is_output)
3635 {
3636     int i;
3637     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3638     if (ic->nb_streams && !printed)
3639         return;
3640
3641     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3642             is_output ? "Output" : "Input",
3643             index,
3644             is_output ? ic->oformat->name : ic->iformat->name,
3645             is_output ? "to" : "from", url);
3646     dump_metadata(NULL, ic->metadata, "  ");
3647     if (!is_output) {
3648         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3649         if (ic->duration != AV_NOPTS_VALUE) {
3650             int hours, mins, secs, us;
3651             int64_t duration = ic->duration + 5000;
3652             secs = duration / AV_TIME_BASE;
3653             us = duration % AV_TIME_BASE;
3654             mins = secs / 60;
3655             secs %= 60;
3656             hours = mins / 60;
3657             mins %= 60;
3658             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3659                    (100 * us) / AV_TIME_BASE);
3660         } else {
3661             av_log(NULL, AV_LOG_INFO, "N/A");
3662         }
3663         if (ic->start_time != AV_NOPTS_VALUE) {
3664             int secs, us;
3665             av_log(NULL, AV_LOG_INFO, ", start: ");
3666             secs = ic->start_time / AV_TIME_BASE;
3667             us = abs(ic->start_time % AV_TIME_BASE);
3668             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3669                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3670         }
3671         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3672         if (ic->bit_rate) {
3673             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3674         } else {
3675             av_log(NULL, AV_LOG_INFO, "N/A");
3676         }
3677         av_log(NULL, AV_LOG_INFO, "\n");
3678     }
3679     for (i = 0; i < ic->nb_chapters; i++) {
3680         AVChapter *ch = ic->chapters[i];
3681         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3682         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3683         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3684
3685         dump_metadata(NULL, ch->metadata, "    ");
3686     }
3687     if(ic->nb_programs) {
3688         int j, k, total = 0;
3689         for(j=0; j<ic->nb_programs; j++) {
3690             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3691                                                   "name", NULL, 0);
3692             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3693                    name ? name->value : "");
3694             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3695             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3696                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3697                 printed[ic->programs[j]->stream_index[k]] = 1;
3698             }
3699             total += ic->programs[j]->nb_stream_indexes;
3700         }
3701         if (total < ic->nb_streams)
3702             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3703     }
3704     for(i=0;i<ic->nb_streams;i++)
3705         if (!printed[i])
3706             dump_stream_format(ic, i, index, is_output);
3707
3708     av_free(printed);
3709 }
3710
3711 uint64_t ff_ntp_time(void)
3712 {
3713   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3714 }
3715
3716 int av_get_frame_filename(char *buf, int buf_size,
3717                           const char *path, int number)
3718 {
3719     const char *p;
3720     char *q, buf1[20], c;
3721     int nd, len, percentd_found;
3722
3723     q = buf;
3724     p = path;
3725     percentd_found = 0;
3726     for(;;) {
3727         c = *p++;
3728         if (c == '\0')
3729             break;
3730         if (c == '%') {
3731             do {
3732                 nd = 0;
3733                 while (av_isdigit(*p)) {
3734                     nd = nd * 10 + *p++ - '0';
3735                 }
3736                 c = *p++;
3737             } while (av_isdigit(c));
3738
3739             switch(c) {
3740             case '%':
3741                 goto addchar;
3742             case 'd':
3743                 if (percentd_found)
3744                     goto fail;
3745                 percentd_found = 1;
3746                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3747                 len = strlen(buf1);
3748                 if ((q - buf + len) > buf_size - 1)
3749                     goto fail;
3750                 memcpy(q, buf1, len);
3751                 q += len;
3752                 break;
3753             default:
3754                 goto fail;
3755             }
3756         } else {
3757         addchar:
3758             if ((q - buf) < buf_size - 1)
3759                 *q++ = c;
3760         }
3761     }
3762     if (!percentd_found)
3763         goto fail;
3764     *q = '\0';
3765     return 0;
3766  fail:
3767     *q = '\0';
3768     return -1;
3769 }
3770
3771 static void hex_dump_internal(void *avcl, FILE *f, int level,
3772                               const uint8_t *buf, int size)
3773 {
3774     int len, i, j, c;
3775 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3776
3777     for(i=0;i<size;i+=16) {
3778         len = size - i;
3779         if (len > 16)
3780             len = 16;
3781         PRINT("%08x ", i);
3782         for(j=0;j<16;j++) {
3783             if (j < len)
3784                 PRINT(" %02x", buf[i+j]);
3785             else
3786                 PRINT("   ");
3787         }
3788         PRINT(" ");
3789         for(j=0;j<len;j++) {
3790             c = buf[i+j];
3791             if (c < ' ' || c > '~')
3792                 c = '.';
3793             PRINT("%c", c);
3794         }
3795         PRINT("\n");
3796     }
3797 #undef PRINT
3798 }
3799
3800 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3801 {
3802     hex_dump_internal(NULL, f, 0, buf, size);
3803 }
3804
3805 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3806 {
3807     hex_dump_internal(avcl, NULL, level, buf, size);
3808 }
3809
3810 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3811 {
3812 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3813     PRINT("stream #%d:\n", pkt->stream_index);
3814     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3815     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3816     /* DTS is _always_ valid after av_read_frame() */
3817     PRINT("  dts=");
3818     if (pkt->dts == AV_NOPTS_VALUE)
3819         PRINT("N/A");
3820     else
3821         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3822     /* PTS may not be known if B-frames are present. */
3823     PRINT("  pts=");
3824     if (pkt->pts == AV_NOPTS_VALUE)
3825         PRINT("N/A");
3826     else
3827         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3828     PRINT("\n");
3829     PRINT("  size=%d\n", pkt->size);
3830 #undef PRINT
3831     if (dump_payload)
3832         av_hex_dump(f, pkt->data, pkt->size);
3833 }
3834
3835 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3836 {
3837     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3838 }
3839
3840 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3841                       AVStream *st)
3842 {
3843     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3844 }
3845
3846 void av_url_split(char *proto, int proto_size,
3847                   char *authorization, int authorization_size,
3848                   char *hostname, int hostname_size,
3849                   int *port_ptr,
3850                   char *path, int path_size,
3851                   const char *url)
3852 {
3853     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3854
3855     if (port_ptr)               *port_ptr = -1;
3856     if (proto_size > 0)         proto[0] = 0;
3857     if (authorization_size > 0) authorization[0] = 0;
3858     if (hostname_size > 0)      hostname[0] = 0;
3859     if (path_size > 0)          path[0] = 0;
3860
3861     /* parse protocol */
3862     if ((p = strchr(url, ':'))) {
3863         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3864         p++; /* skip ':' */
3865         if (*p == '/') p++;
3866         if (*p == '/') p++;
3867     } else {
3868         /* no protocol means plain filename */
3869         av_strlcpy(path, url, path_size);
3870         return;
3871     }
3872
3873     /* separate path from hostname */
3874     ls = strchr(p, '/');
3875     ls2 = strchr(p, '?');
3876     if(!ls)
3877         ls = ls2;
3878     else if (ls && ls2)
3879         ls = FFMIN(ls, ls2);
3880     if(ls)
3881         av_strlcpy(path, ls, path_size);
3882     else
3883         ls = &p[strlen(p)]; // XXX
3884
3885     /* the rest is hostname, use that to parse auth/port */
3886     if (ls != p) {
3887         /* authorization (user[:pass]@hostname) */
3888         at2 = p;
3889         while ((at = strchr(p, '@')) && at < ls) {
3890             av_strlcpy(authorization, at2,
3891                        FFMIN(authorization_size, at + 1 - at2));
3892             p = at + 1; /* skip '@' */
3893         }
3894
3895         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3896             /* [host]:port */
3897             av_strlcpy(hostname, p + 1,
3898                        FFMIN(hostname_size, brk - p));
3899             if (brk[1] == ':' && port_ptr)
3900                 *port_ptr = atoi(brk + 2);
3901         } else if ((col = strchr(p, ':')) && col < ls) {
3902             av_strlcpy(hostname, p,
3903                        FFMIN(col + 1 - p, hostname_size));
3904             if (port_ptr) *port_ptr = atoi(col + 1);
3905         } else
3906             av_strlcpy(hostname, p,
3907                        FFMIN(ls + 1 - p, hostname_size));
3908     }
3909 }
3910
3911 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3912 {
3913     int i;
3914     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3915                                            '4', '5', '6', '7',
3916                                            '8', '9', 'A', 'B',
3917                                            'C', 'D', 'E', 'F' };
3918     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3919                                            '4', '5', '6', '7',
3920                                            '8', '9', 'a', 'b',
3921                                            'c', 'd', 'e', 'f' };
3922     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3923
3924     for(i = 0; i < s; i++) {
3925         buff[i * 2]     = hex_table[src[i] >> 4];
3926         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3927     }
3928
3929     return buff;
3930 }
3931
3932 int ff_hex_to_data(uint8_t *data, const char *p)
3933 {
3934     int c, len, v;
3935
3936     len = 0;
3937     v = 1;
3938     for (;;) {
3939         p += strspn(p, SPACE_CHARS);
3940         if (*p == '\0')
3941             break;
3942         c = av_toupper((unsigned char) *p++);
3943         if (c >= '0' && c <= '9')
3944             c = c - '0';
3945         else if (c >= 'A' && c <= 'F')
3946             c = c - 'A' + 10;
3947         else
3948             break;
3949         v = (v << 4) | c;
3950         if (v & 0x100) {
3951             if (data)
3952                 data[len] = v;
3953             len++;
3954             v = 1;
3955         }
3956     }
3957     return len;
3958 }
3959
3960 #if FF_API_SET_PTS_INFO
3961 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3962                      unsigned int pts_num, unsigned int pts_den)
3963 {
3964     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3965 }
3966 #endif
3967
3968 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3969                          unsigned int pts_num, unsigned int pts_den)
3970 {
3971     AVRational new_tb;
3972     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3973         if(new_tb.num != pts_num)
3974             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3975     }else
3976         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3977
3978     if(new_tb.num <= 0 || new_tb.den <= 0) {
3979         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase %d/%d for st:%d\n", new_tb.num, new_tb.den, s->index);
3980         return;
3981     }
3982     s->time_base = new_tb;
3983     av_codec_set_pkt_timebase(s->codec, new_tb);
3984     s->pts_wrap_bits = pts_wrap_bits;
3985 }
3986
3987 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3988                         void *context)
3989 {
3990     const char *ptr = str;
3991
3992     /* Parse key=value pairs. */
3993     for (;;) {
3994         const char *key;
3995         char *dest = NULL, *dest_end;
3996         int key_len, dest_len = 0;
3997
3998         /* Skip whitespace and potential commas. */
3999         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4000             ptr++;
4001         if (!*ptr)
4002             break;
4003
4004         key = ptr;
4005
4006         if (!(ptr = strchr(key, '=')))
4007             break;
4008         ptr++;
4009         key_len = ptr - key;
4010
4011         callback_get_buf(context, key, key_len, &dest, &dest_len);
4012         dest_end = dest + dest_len - 1;
4013
4014         if (*ptr == '\"') {
4015             ptr++;
4016             while (*ptr && *ptr != '\"') {
4017                 if (*ptr == '\\') {
4018                     if (!ptr[1])
4019                         break;
4020                     if (dest && dest < dest_end)
4021                         *dest++ = ptr[1];
4022                     ptr += 2;
4023                 } else {
4024                     if (dest && dest < dest_end)
4025                         *dest++ = *ptr;
4026                     ptr++;
4027                 }
4028             }
4029             if (*ptr == '\"')
4030                 ptr++;
4031         } else {
4032             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4033                 if (dest && dest < dest_end)
4034                     *dest++ = *ptr;
4035         }
4036         if (dest)
4037             *dest = 0;
4038     }
4039 }
4040
4041 int ff_find_stream_index(AVFormatContext *s, int id)
4042 {
4043     int i;
4044     for (i = 0; i < s->nb_streams; i++) {
4045         if (s->streams[i]->id == id)
4046             return i;
4047     }
4048     return -1;
4049 }
4050
4051 int64_t ff_iso8601_to_unix_time(const char *datestr)
4052 {
4053     struct tm time1 = {0}, time2 = {0};
4054     char *ret1, *ret2;
4055     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4056     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4057     if (ret2 && !ret1)
4058         return av_timegm(&time2);
4059     else
4060         return av_timegm(&time1);
4061 }
4062
4063 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4064 {
4065     if (ofmt) {
4066         if (ofmt->query_codec)
4067             return ofmt->query_codec(codec_id, std_compliance);
4068         else if (ofmt->codec_tag)
4069             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4070         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4071                  codec_id == ofmt->subtitle_codec)
4072             return 1;
4073     }
4074     return AVERROR_PATCHWELCOME;
4075 }
4076
4077 int avformat_network_init(void)
4078 {
4079 #if CONFIG_NETWORK
4080     int ret;
4081     ff_network_inited_globally = 1;
4082     if ((ret = ff_network_init()) < 0)
4083         return ret;
4084     ff_tls_init();
4085 #endif
4086     return 0;
4087 }
4088
4089 int avformat_network_deinit(void)
4090 {
4091 #if CONFIG_NETWORK
4092     ff_network_close();
4093     ff_tls_deinit();
4094 #endif
4095     return 0;
4096 }
4097
4098 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4099                         uint64_t channel_layout, int32_t sample_rate,
4100                         int32_t width, int32_t height)
4101 {
4102     uint32_t flags = 0;
4103     int size = 4;
4104     uint8_t *data;
4105     if (!pkt)
4106         return AVERROR(EINVAL);
4107     if (channels) {
4108         size += 4;
4109         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4110     }
4111     if (channel_layout) {
4112         size += 8;
4113         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4114     }
4115     if (sample_rate) {
4116         size += 4;
4117         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4118     }
4119     if (width || height) {
4120         size += 8;
4121         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4122     }
4123     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4124     if (!data)
4125         return AVERROR(ENOMEM);
4126     bytestream_put_le32(&data, flags);
4127     if (channels)
4128         bytestream_put_le32(&data, channels);
4129     if (channel_layout)
4130         bytestream_put_le64(&data, channel_layout);
4131     if (sample_rate)
4132         bytestream_put_le32(&data, sample_rate);
4133     if (width || height) {
4134         bytestream_put_le32(&data, width);
4135         bytestream_put_le32(&data, height);
4136     }
4137     return 0;
4138 }
4139
4140 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4141 {
4142     AVRational undef = {0, 1};
4143     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4144     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4145     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4146
4147     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4148                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4149     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4150         stream_sample_aspect_ratio = undef;
4151
4152     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4153                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4154     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4155         frame_sample_aspect_ratio = undef;
4156
4157     if (stream_sample_aspect_ratio.num)
4158         return stream_sample_aspect_ratio;
4159     else
4160         return frame_sample_aspect_ratio;
4161 }
4162
4163 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4164 {
4165     AVRational fr = st->r_frame_rate;
4166
4167     if (st->codec->ticks_per_frame > 1) {
4168         AVRational codec_fr = av_inv_q(st->codec->time_base);
4169         AVRational   avg_fr = st->avg_frame_rate;
4170         codec_fr.den *= st->codec->ticks_per_frame;
4171         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4172             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4173             fr = codec_fr;
4174     }
4175
4176     return fr;
4177 }
4178
4179 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4180                                     const char *spec)
4181 {
4182     if (*spec <= '9' && *spec >= '0') /* opt:index */
4183         return strtol(spec, NULL, 0) == st->index;
4184     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4185              *spec == 't') { /* opt:[vasdt] */
4186         enum AVMediaType type;
4187
4188         switch (*spec++) {
4189         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4190         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4191         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4192         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4193         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4194         default:  av_assert0(0);
4195         }
4196         if (type != st->codec->codec_type)
4197             return 0;
4198         if (*spec++ == ':') { /* possibly followed by :index */
4199             int i, index = strtol(spec, NULL, 0);
4200             for (i = 0; i < s->nb_streams; i++)
4201                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4202                    return i == st->index;
4203             return 0;
4204         }
4205         return 1;
4206     } else if (*spec == 'p' && *(spec + 1) == ':') {
4207         int prog_id, i, j;
4208         char *endptr;
4209         spec += 2;
4210         prog_id = strtol(spec, &endptr, 0);
4211         for (i = 0; i < s->nb_programs; i++) {
4212             if (s->programs[i]->id != prog_id)
4213                 continue;
4214
4215             if (*endptr++ == ':') {
4216                 int stream_idx = strtol(endptr, NULL, 0);
4217                 return stream_idx >= 0 &&
4218                     stream_idx < s->programs[i]->nb_stream_indexes &&
4219                     st->index == s->programs[i]->stream_index[stream_idx];
4220             }
4221
4222             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4223                 if (st->index == s->programs[i]->stream_index[j])
4224                     return 1;
4225         }
4226         return 0;
4227     } else if (*spec == '#') {
4228         int sid;
4229         char *endptr;
4230         sid = strtol(spec + 1, &endptr, 0);
4231         if (!*endptr)
4232             return st->id == sid;
4233     } else if (!*spec) /* empty specifier, matches everything */
4234         return 1;
4235
4236     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4237     return AVERROR(EINVAL);
4238 }
4239
4240 int ff_generate_avci_extradata(AVStream *st)
4241 {
4242     static const uint8_t avci100_1080p_extradata[] = {
4243         // SPS
4244         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4245         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4246         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4247         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4248         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4249         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4250         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4251         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4252         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4253         // PPS
4254         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4255         0xd0
4256     };
4257     static const uint8_t avci100_1080i_extradata[] = {
4258         // SPS
4259         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4260         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4261         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4262         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4263         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4264         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4265         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4266         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4267         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4268         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4269         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4270         // PPS
4271         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4272         0xd0
4273     };
4274     static const uint8_t avci50_1080i_extradata[] = {
4275         // SPS
4276         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4277         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4278         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4279         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4280         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4281         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4282         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4283         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4284         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4285         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4286         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4287         // PPS
4288         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4289         0x11
4290     };
4291     static const uint8_t avci100_720p_extradata[] = {
4292         // SPS
4293         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4294         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4295         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4296         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4297         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4298         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4299         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4300         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4301         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4302         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4303         // PPS
4304         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4305         0x11
4306     };
4307
4308     const uint8_t *data = NULL;
4309     int size = 0;
4310
4311     if (st->codec->width == 1920) {
4312         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4313             data = avci100_1080p_extradata;
4314             size = sizeof(avci100_1080p_extradata);
4315         } else {
4316             data = avci100_1080i_extradata;
4317             size = sizeof(avci100_1080i_extradata);
4318         }
4319     } else if (st->codec->width == 1440) {
4320         data = avci50_1080i_extradata;
4321         size = sizeof(avci50_1080i_extradata);
4322     } else if (st->codec->width == 1280) {
4323         data = avci100_720p_extradata;
4324         size = sizeof(avci100_720p_extradata);
4325     }
4326
4327     if (!size)
4328         return 0;
4329
4330     av_freep(&st->codec->extradata);
4331     if (ff_alloc_extradata(st->codec, size))
4332         return AVERROR(ENOMEM);
4333     memcpy(st->codec->extradata, data, size);
4334
4335     return 0;
4336 }