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")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1083             pkt->dts= AV_NOPTS_VALUE;
1084     }
1085
1086     if (pkt->duration == 0) {
1087         ff_compute_frame_duration(&num, &den, st, pc, pkt);
1088         if (den && num) {
1089             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1090         }
1091     }
1092     if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1093         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1094
1095     /* correct timestamps with byte offset if demuxers only have timestamps
1096        on packet boundaries */
1097     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1098         /* this will estimate bitrate based on this frame's duration and size */
1099         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1100         if(pkt->pts != AV_NOPTS_VALUE)
1101             pkt->pts += offset;
1102         if(pkt->dts != AV_NOPTS_VALUE)
1103             pkt->dts += offset;
1104     }
1105
1106     /* This may be redundant, but it should not hurt. */
1107     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1108         presentation_delayed = 1;
1109
1110     av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1111            presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1112     /* interpolate PTS and DTS if they are not present */
1113     //We skip H264 currently because delay and has_b_frames are not reliably set
1114     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1115         if (presentation_delayed) {
1116             /* DTS = decompression timestamp */
1117             /* PTS = presentation timestamp */
1118             if (pkt->dts == AV_NOPTS_VALUE)
1119                 pkt->dts = st->last_IP_pts;
1120             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1121             if (pkt->dts == AV_NOPTS_VALUE)
1122                 pkt->dts = st->cur_dts;
1123
1124             /* this is tricky: the dts must be incremented by the duration
1125             of the frame we are displaying, i.e. the last I- or P-frame */
1126             if (st->last_IP_duration == 0)
1127                 st->last_IP_duration = pkt->duration;
1128             if(pkt->dts != AV_NOPTS_VALUE)
1129                 st->cur_dts = pkt->dts + st->last_IP_duration;
1130             st->last_IP_duration  = pkt->duration;
1131             st->last_IP_pts= pkt->pts;
1132             /* cannot compute PTS if not present (we can compute it only
1133             by knowing the future */
1134         } else if (pkt->pts != AV_NOPTS_VALUE ||
1135                    pkt->dts != AV_NOPTS_VALUE ||
1136                    pkt->duration                ) {
1137             int duration = pkt->duration;
1138
1139             /* presentation is not delayed : PTS and DTS are the same */
1140             if (pkt->pts == AV_NOPTS_VALUE)
1141                 pkt->pts = pkt->dts;
1142             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1143                                       pkt->pts, pkt);
1144             if (pkt->pts == AV_NOPTS_VALUE)
1145                 pkt->pts = st->cur_dts;
1146             pkt->dts = pkt->pts;
1147             if (pkt->pts != AV_NOPTS_VALUE)
1148                 st->cur_dts = pkt->pts + duration;
1149         }
1150     }
1151
1152     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1153         st->pts_buffer[0]= pkt->pts;
1154         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1155             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1156         if(pkt->dts == AV_NOPTS_VALUE)
1157             pkt->dts= st->pts_buffer[0];
1158     }
1159     if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1160         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1161     }
1162     if(pkt->dts > st->cur_dts)
1163         st->cur_dts = pkt->dts;
1164
1165     av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1166             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1167
1168     /* update flags */
1169     if (is_intra_only(st->codec))
1170         pkt->flags |= AV_PKT_FLAG_KEY;
1171     if (pc)
1172         pkt->convergence_duration = pc->convergence_duration;
1173 }
1174
1175 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1176 {
1177     while (*pkt_buf) {
1178         AVPacketList *pktl = *pkt_buf;
1179         *pkt_buf = pktl->next;
1180         av_free_packet(&pktl->pkt);
1181         av_freep(&pktl);
1182     }
1183     *pkt_buf_end = NULL;
1184 }
1185
1186 /**
1187  * Parse a packet, add all split parts to parse_queue
1188  *
1189  * @param pkt packet to parse, NULL when flushing the parser at end of stream
1190  */
1191 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1192 {
1193     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1194     AVStream     *st = s->streams[stream_index];
1195     uint8_t    *data = pkt ? pkt->data : NULL;
1196     int         size = pkt ? pkt->size : 0;
1197     int ret = 0, got_output = 0;
1198
1199     if (!pkt) {
1200         av_init_packet(&flush_pkt);
1201         pkt = &flush_pkt;
1202         got_output = 1;
1203     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1204         // preserve 0-size sync packets
1205         compute_pkt_fields(s, st, st->parser, pkt);
1206     }
1207
1208     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1209         int len;
1210
1211         av_init_packet(&out_pkt);
1212         len = av_parser_parse2(st->parser,  st->codec,
1213                                &out_pkt.data, &out_pkt.size, data, size,
1214                                pkt->pts, pkt->dts, pkt->pos);
1215
1216         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1217         pkt->pos = -1;
1218         /* increment read pointer */
1219         data += len;
1220         size -= len;
1221
1222         got_output = !!out_pkt.size;
1223
1224         if (!out_pkt.size)
1225             continue;
1226
1227         if (pkt->side_data) {
1228             out_pkt.side_data       = pkt->side_data;
1229             out_pkt.side_data_elems = pkt->side_data_elems;
1230             pkt->side_data       = NULL;
1231             pkt->side_data_elems = 0;
1232         }
1233
1234         /* set the duration */
1235         out_pkt.duration = 0;
1236         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1237             if (st->codec->sample_rate > 0) {
1238                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1239                                                     (AVRational){ 1, st->codec->sample_rate },
1240                                                     st->time_base,
1241                                                     AV_ROUND_DOWN);
1242             }
1243         } else if (st->codec->time_base.num != 0 &&
1244                    st->codec->time_base.den != 0) {
1245             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1246                                                 st->codec->time_base,
1247                                                 st->time_base,
1248                                                 AV_ROUND_DOWN);
1249         }
1250
1251         out_pkt.stream_index = st->index;
1252         out_pkt.pts = st->parser->pts;
1253         out_pkt.dts = st->parser->dts;
1254         out_pkt.pos = st->parser->pos;
1255
1256         if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1257             out_pkt.pos = st->parser->frame_offset;
1258
1259         if (st->parser->key_frame == 1 ||
1260             (st->parser->key_frame == -1 &&
1261              st->parser->pict_type == AV_PICTURE_TYPE_I))
1262             out_pkt.flags |= AV_PKT_FLAG_KEY;
1263
1264         if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1265             out_pkt.flags |= AV_PKT_FLAG_KEY;
1266
1267         compute_pkt_fields(s, st, st->parser, &out_pkt);
1268
1269         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1270             out_pkt.buf   = pkt->buf;
1271             pkt->buf      = NULL;
1272 #if FF_API_DESTRUCT_PACKET
1273 FF_DISABLE_DEPRECATION_WARNINGS
1274             out_pkt.destruct = pkt->destruct;
1275             pkt->destruct = NULL;
1276 FF_ENABLE_DEPRECATION_WARNINGS
1277 #endif
1278         }
1279         if ((ret = av_dup_packet(&out_pkt)) < 0)
1280             goto fail;
1281
1282         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1283             av_free_packet(&out_pkt);
1284             ret = AVERROR(ENOMEM);
1285             goto fail;
1286         }
1287     }
1288
1289
1290     /* end of the stream => close and free the parser */
1291     if (pkt == &flush_pkt) {
1292         av_parser_close(st->parser);
1293         st->parser = NULL;
1294     }
1295
1296 fail:
1297     av_free_packet(pkt);
1298     return ret;
1299 }
1300
1301 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1302                                    AVPacketList **pkt_buffer_end,
1303                                    AVPacket      *pkt)
1304 {
1305     AVPacketList *pktl;
1306     av_assert0(*pkt_buffer);
1307     pktl = *pkt_buffer;
1308     *pkt = pktl->pkt;
1309     *pkt_buffer = pktl->next;
1310     if (!pktl->next)
1311         *pkt_buffer_end = NULL;
1312     av_freep(&pktl);
1313     return 0;
1314 }
1315
1316 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1317 {
1318     int ret = 0, i, got_packet = 0;
1319
1320     av_init_packet(pkt);
1321
1322     while (!got_packet && !s->parse_queue) {
1323         AVStream *st;
1324         AVPacket cur_pkt;
1325
1326         /* read next packet */
1327         ret = ff_read_packet(s, &cur_pkt);
1328         if (ret < 0) {
1329             if (ret == AVERROR(EAGAIN))
1330                 return ret;
1331             /* flush the parsers */
1332             for(i = 0; i < s->nb_streams; i++) {
1333                 st = s->streams[i];
1334                 if (st->parser && st->need_parsing)
1335                     parse_packet(s, NULL, st->index);
1336             }
1337             /* all remaining packets are now in parse_queue =>
1338              * really terminate parsing */
1339             break;
1340         }
1341         ret = 0;
1342         st  = s->streams[cur_pkt.stream_index];
1343
1344         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1345             cur_pkt.dts != AV_NOPTS_VALUE &&
1346             cur_pkt.pts < cur_pkt.dts) {
1347             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1348                    cur_pkt.stream_index,
1349                    av_ts2str(cur_pkt.pts),
1350                    av_ts2str(cur_pkt.dts),
1351                    cur_pkt.size);
1352         }
1353         if (s->debug & FF_FDEBUG_TS)
1354             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1355                    cur_pkt.stream_index,
1356                    av_ts2str(cur_pkt.pts),
1357                    av_ts2str(cur_pkt.dts),
1358                    cur_pkt.size,
1359                    cur_pkt.duration,
1360                    cur_pkt.flags);
1361
1362         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1363             st->parser = av_parser_init(st->codec->codec_id);
1364             if (!st->parser) {
1365                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1366                        "%s, packets or times may be invalid.\n",
1367                        avcodec_get_name(st->codec->codec_id));
1368                 /* no parser available: just output the raw packets */
1369                 st->need_parsing = AVSTREAM_PARSE_NONE;
1370             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1371                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1372             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1373                 st->parser->flags |= PARSER_FLAG_ONCE;
1374             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1375                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1376             }
1377         }
1378
1379         if (!st->need_parsing || !st->parser) {
1380             /* no parsing needed: we just output the packet as is */
1381             *pkt = cur_pkt;
1382             compute_pkt_fields(s, st, NULL, pkt);
1383             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1384                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1385                 ff_reduce_index(s, st->index);
1386                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1387             }
1388             got_packet = 1;
1389         } else if (st->discard < AVDISCARD_ALL) {
1390             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1391                 return ret;
1392         } else {
1393             /* free packet */
1394             av_free_packet(&cur_pkt);
1395         }
1396         if (pkt->flags & AV_PKT_FLAG_KEY)
1397             st->skip_to_keyframe = 0;
1398         if (st->skip_to_keyframe) {
1399             av_free_packet(&cur_pkt);
1400             if (got_packet) {
1401                 *pkt = cur_pkt;
1402             }
1403             got_packet = 0;
1404         }
1405     }
1406
1407     if (!got_packet && s->parse_queue)
1408         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1409
1410     if (ret >= 0) {
1411         AVStream *st = s->streams[pkt->stream_index];
1412         if (st->skip_samples) {
1413             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1414             if (p) {
1415                 AV_WL32(p, st->skip_samples);
1416                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1417             }
1418             st->skip_samples = 0;
1419         }
1420     }
1421
1422     if(ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1423         av_packet_merge_side_data(pkt);
1424
1425     if(s->debug & FF_FDEBUG_TS)
1426         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1427             pkt->stream_index,
1428             av_ts2str(pkt->pts),
1429             av_ts2str(pkt->dts),
1430             pkt->size,
1431             pkt->duration,
1432             pkt->flags);
1433
1434     return ret;
1435 }
1436
1437 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1438 {
1439     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1440     int          eof = 0;
1441     int ret;
1442     AVStream *st;
1443
1444     if (!genpts) {
1445         ret = s->packet_buffer ?
1446             read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1447             read_frame_internal(s, pkt);
1448         if (ret < 0)
1449             return ret;
1450         goto return_packet;
1451     }
1452
1453     for (;;) {
1454         AVPacketList *pktl = s->packet_buffer;
1455
1456         if (pktl) {
1457             AVPacket *next_pkt = &pktl->pkt;
1458
1459             if (next_pkt->dts != AV_NOPTS_VALUE) {
1460                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1461                 // last dts seen for this stream. if any of packets following
1462                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1463                 int64_t last_dts = next_pkt->dts;
1464                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1465                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1466                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1467                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1468                             next_pkt->pts = pktl->pkt.dts;
1469                         }
1470                         if (last_dts != AV_NOPTS_VALUE) {
1471                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1472                             last_dts = pktl->pkt.dts;
1473                         }
1474                     }
1475                     pktl = pktl->next;
1476                 }
1477                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1478                     // Fixing the last reference frame had none pts issue (For MXF etc).
1479                     // We only do this when
1480                     // 1. eof.
1481                     // 2. we are not able to resolve a pts value for current packet.
1482                     // 3. the packets for this stream at the end of the files had valid dts.
1483                     next_pkt->pts = last_dts + next_pkt->duration;
1484                 }
1485                 pktl = s->packet_buffer;
1486             }
1487
1488             /* read packet from packet buffer, if there is data */
1489             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1490                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1491                 ret = read_from_packet_buffer(&s->packet_buffer,
1492                                                &s->packet_buffer_end, pkt);
1493                 goto return_packet;
1494             }
1495         }
1496
1497         ret = read_frame_internal(s, pkt);
1498         if (ret < 0) {
1499             if (pktl && ret != AVERROR(EAGAIN)) {
1500                 eof = 1;
1501                 continue;
1502             } else
1503                 return ret;
1504         }
1505
1506         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1507                           &s->packet_buffer_end)) < 0)
1508             return AVERROR(ENOMEM);
1509     }
1510
1511 return_packet:
1512
1513     st = s->streams[pkt->stream_index];
1514     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1515         ff_reduce_index(s, st->index);
1516         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1517     }
1518
1519     if (is_relative(pkt->dts))
1520         pkt->dts -= RELATIVE_TS_BASE;
1521     if (is_relative(pkt->pts))
1522         pkt->pts -= RELATIVE_TS_BASE;
1523
1524     return ret;
1525 }
1526
1527 /* XXX: suppress the packet queue */
1528 static void flush_packet_queue(AVFormatContext *s)
1529 {
1530     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1531     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1532     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1533
1534     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1535 }
1536
1537 /*******************************************************/
1538 /* seek support */
1539
1540 int av_find_default_stream_index(AVFormatContext *s)
1541 {
1542     int first_audio_index = -1;
1543     int i;
1544     AVStream *st;
1545
1546     if (s->nb_streams <= 0)
1547         return -1;
1548     for(i = 0; i < s->nb_streams; i++) {
1549         st = s->streams[i];
1550         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1551             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1552             return i;
1553         }
1554         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1555             first_audio_index = i;
1556     }
1557     return first_audio_index >= 0 ? first_audio_index : 0;
1558 }
1559
1560 /**
1561  * Flush the frame reader.
1562  */
1563 void ff_read_frame_flush(AVFormatContext *s)
1564 {
1565     AVStream *st;
1566     int i, j;
1567
1568     flush_packet_queue(s);
1569
1570     /* for each stream, reset read state */
1571     for(i = 0; i < s->nb_streams; i++) {
1572         st = s->streams[i];
1573
1574         if (st->parser) {
1575             av_parser_close(st->parser);
1576             st->parser = NULL;
1577         }
1578         st->last_IP_pts = AV_NOPTS_VALUE;
1579         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1580         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1581
1582         st->probe_packets = MAX_PROBE_PACKETS;
1583
1584         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1585             st->pts_buffer[j]= AV_NOPTS_VALUE;
1586     }
1587 }
1588
1589 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1590 {
1591     int i;
1592
1593     for(i = 0; i < s->nb_streams; i++) {
1594         AVStream *st = s->streams[i];
1595
1596         st->cur_dts = av_rescale(timestamp,
1597                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1598                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1599     }
1600 }
1601
1602 void ff_reduce_index(AVFormatContext *s, int stream_index)
1603 {
1604     AVStream *st= s->streams[stream_index];
1605     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1606
1607     if((unsigned)st->nb_index_entries >= max_entries){
1608         int i;
1609         for(i=0; 2*i<st->nb_index_entries; i++)
1610             st->index_entries[i]= st->index_entries[2*i];
1611         st->nb_index_entries= i;
1612     }
1613 }
1614
1615 int ff_add_index_entry(AVIndexEntry **index_entries,
1616                        int *nb_index_entries,
1617                        unsigned int *index_entries_allocated_size,
1618                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1619 {
1620     AVIndexEntry *entries, *ie;
1621     int index;
1622
1623     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1624         return -1;
1625
1626     if(timestamp == AV_NOPTS_VALUE)
1627         return AVERROR(EINVAL);
1628
1629     if (size < 0 || size > 0x3FFFFFFF)
1630         return AVERROR(EINVAL);
1631
1632     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1633         timestamp -= RELATIVE_TS_BASE;
1634
1635     entries = av_fast_realloc(*index_entries,
1636                               index_entries_allocated_size,
1637                               (*nb_index_entries + 1) *
1638                               sizeof(AVIndexEntry));
1639     if(!entries)
1640         return -1;
1641
1642     *index_entries= entries;
1643
1644     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1645
1646     if(index<0){
1647         index= (*nb_index_entries)++;
1648         ie= &entries[index];
1649         av_assert0(index==0 || ie[-1].timestamp < timestamp);
1650     }else{
1651         ie= &entries[index];
1652         if(ie->timestamp != timestamp){
1653             if(ie->timestamp <= timestamp)
1654                 return -1;
1655             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1656             (*nb_index_entries)++;
1657         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1658             distance= ie->min_distance;
1659     }
1660
1661     ie->pos = pos;
1662     ie->timestamp = timestamp;
1663     ie->min_distance= distance;
1664     ie->size= size;
1665     ie->flags = flags;
1666
1667     return index;
1668 }
1669
1670 int av_add_index_entry(AVStream *st,
1671                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1672 {
1673     timestamp = wrap_timestamp(st, timestamp);
1674     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1675                               &st->index_entries_allocated_size, pos,
1676                               timestamp, size, distance, flags);
1677 }
1678
1679 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1680                               int64_t wanted_timestamp, int flags)
1681 {
1682     int a, b, m;
1683     int64_t timestamp;
1684
1685     a = - 1;
1686     b = nb_entries;
1687
1688     //optimize appending index entries at the end
1689     if(b && entries[b-1].timestamp < wanted_timestamp)
1690         a= b-1;
1691
1692     while (b - a > 1) {
1693         m = (a + b) >> 1;
1694         timestamp = entries[m].timestamp;
1695         if(timestamp >= wanted_timestamp)
1696             b = m;
1697         if(timestamp <= wanted_timestamp)
1698             a = m;
1699     }
1700     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1701
1702     if(!(flags & AVSEEK_FLAG_ANY)){
1703         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1704             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1705         }
1706     }
1707
1708     if(m == nb_entries)
1709         return -1;
1710     return  m;
1711 }
1712
1713 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1714                               int flags)
1715 {
1716     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1717                                      wanted_timestamp, flags);
1718 }
1719
1720 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1721                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1722 {
1723     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1724     if (stream_index >= 0)
1725         ts = wrap_timestamp(s->streams[stream_index], ts);
1726     return ts;
1727 }
1728
1729 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1730 {
1731     AVInputFormat *avif= s->iformat;
1732     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1733     int64_t ts_min, ts_max, ts;
1734     int index;
1735     int64_t ret;
1736     AVStream *st;
1737
1738     if (stream_index < 0)
1739         return -1;
1740
1741     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1742
1743     ts_max=
1744     ts_min= AV_NOPTS_VALUE;
1745     pos_limit= -1; //gcc falsely says it may be uninitialized
1746
1747     st= s->streams[stream_index];
1748     if(st->index_entries){
1749         AVIndexEntry *e;
1750
1751         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()
1752         index= FFMAX(index, 0);
1753         e= &st->index_entries[index];
1754
1755         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1756             pos_min= e->pos;
1757             ts_min= e->timestamp;
1758             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1759                     pos_min, av_ts2str(ts_min));
1760         }else{
1761             av_assert1(index==0);
1762         }
1763
1764         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1765         av_assert0(index < st->nb_index_entries);
1766         if(index >= 0){
1767             e= &st->index_entries[index];
1768             av_assert1(e->timestamp >= target_ts);
1769             pos_max= e->pos;
1770             ts_max= e->timestamp;
1771             pos_limit= pos_max - e->min_distance;
1772             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1773                     pos_max, pos_limit, av_ts2str(ts_max));
1774         }
1775     }
1776
1777     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1778     if(pos<0)
1779         return -1;
1780
1781     /* do the seek */
1782     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1783         return ret;
1784
1785     ff_read_frame_flush(s);
1786     ff_update_cur_dts(s, st, ts);
1787
1788     return 0;
1789 }
1790
1791 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1792                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1793 {
1794     int64_t step= 1024;
1795     int64_t limit, ts_max;
1796     int64_t filesize = avio_size(s->pb);
1797     int64_t pos_max = filesize - 1;
1798     do{
1799         limit = pos_max;
1800         pos_max = FFMAX(0, (pos_max) - step);
1801         ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1802         step += step;
1803     }while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1804     if (ts_max == AV_NOPTS_VALUE)
1805         return -1;
1806
1807     for(;;){
1808         int64_t tmp_pos = pos_max + 1;
1809         int64_t tmp_ts = ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1810         if(tmp_ts == AV_NOPTS_VALUE)
1811             break;
1812         av_assert0(tmp_pos > pos_max);
1813         ts_max  = tmp_ts;
1814         pos_max = tmp_pos;
1815         if(tmp_pos >= filesize)
1816             break;
1817     }
1818
1819     if (ts)
1820         *ts = ts_max;
1821     if (pos)
1822         *pos = pos_max;
1823
1824     return 0;
1825 }
1826
1827 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1828                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1829                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1830                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1831 {
1832     int64_t pos, ts;
1833     int64_t start_pos;
1834     int no_change;
1835     int ret;
1836
1837     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1838
1839     if(ts_min == AV_NOPTS_VALUE){
1840         pos_min = s->data_offset;
1841         ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1842         if (ts_min == AV_NOPTS_VALUE)
1843             return -1;
1844     }
1845
1846     if(ts_min >= target_ts){
1847         *ts_ret= ts_min;
1848         return pos_min;
1849     }
1850
1851     if(ts_max == AV_NOPTS_VALUE){
1852         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1853             return ret;
1854         pos_limit= pos_max;
1855     }
1856
1857     if(ts_max <= target_ts){
1858         *ts_ret= ts_max;
1859         return pos_max;
1860     }
1861
1862     if(ts_min > ts_max){
1863         return -1;
1864     }else if(ts_min == ts_max){
1865         pos_limit= pos_min;
1866     }
1867
1868     no_change=0;
1869     while (pos_min < pos_limit) {
1870         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1871                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1872         assert(pos_limit <= pos_max);
1873
1874         if(no_change==0){
1875             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1876             // interpolate position (better than dichotomy)
1877             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1878                 + pos_min - approximate_keyframe_distance;
1879         }else if(no_change==1){
1880             // bisection, if interpolation failed to change min or max pos last time
1881             pos = (pos_min + pos_limit)>>1;
1882         }else{
1883             /* linear search if bisection failed, can only happen if there
1884                are very few or no keyframes between min/max */
1885             pos=pos_min;
1886         }
1887         if(pos <= pos_min)
1888             pos= pos_min + 1;
1889         else if(pos > pos_limit)
1890             pos= pos_limit;
1891         start_pos= pos;
1892
1893         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1894         if(pos == pos_max)
1895             no_change++;
1896         else
1897             no_change=0;
1898         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1899                 pos_min, pos, pos_max,
1900                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1901                 pos_limit, start_pos, no_change);
1902         if(ts == AV_NOPTS_VALUE){
1903             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1904             return -1;
1905         }
1906         assert(ts != AV_NOPTS_VALUE);
1907         if (target_ts <= ts) {
1908             pos_limit = start_pos - 1;
1909             pos_max = pos;
1910             ts_max = ts;
1911         }
1912         if (target_ts >= ts) {
1913             pos_min = pos;
1914             ts_min = ts;
1915         }
1916     }
1917
1918     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1919     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1920 #if 0
1921     pos_min = pos;
1922     ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1923     pos_min++;
1924     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1925     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1926             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1927 #endif
1928     *ts_ret= ts;
1929     return pos;
1930 }
1931
1932 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1933     int64_t pos_min, pos_max;
1934
1935     pos_min = s->data_offset;
1936     pos_max = avio_size(s->pb) - 1;
1937
1938     if     (pos < pos_min) pos= pos_min;
1939     else if(pos > pos_max) pos= pos_max;
1940
1941     avio_seek(s->pb, pos, SEEK_SET);
1942
1943     s->io_repositioned = 1;
1944
1945     return 0;
1946 }
1947
1948 static int seek_frame_generic(AVFormatContext *s,
1949                                  int stream_index, int64_t timestamp, int flags)
1950 {
1951     int index;
1952     int64_t ret;
1953     AVStream *st;
1954     AVIndexEntry *ie;
1955
1956     st = s->streams[stream_index];
1957
1958     index = av_index_search_timestamp(st, timestamp, flags);
1959
1960     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1961         return -1;
1962
1963     if(index < 0 || index==st->nb_index_entries-1){
1964         AVPacket pkt;
1965         int nonkey=0;
1966
1967         if(st->nb_index_entries){
1968             av_assert0(st->index_entries);
1969             ie= &st->index_entries[st->nb_index_entries-1];
1970             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1971                 return ret;
1972             ff_update_cur_dts(s, st, ie->timestamp);
1973         }else{
1974             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1975                 return ret;
1976         }
1977         for (;;) {
1978             int read_status;
1979             do{
1980                 read_status = av_read_frame(s, &pkt);
1981             } while (read_status == AVERROR(EAGAIN));
1982             if (read_status < 0)
1983                 break;
1984             av_free_packet(&pkt);
1985             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1986                 if(pkt.flags & AV_PKT_FLAG_KEY)
1987                     break;
1988                 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1989                     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);
1990                     break;
1991                 }
1992             }
1993         }
1994         index = av_index_search_timestamp(st, timestamp, flags);
1995     }
1996     if (index < 0)
1997         return -1;
1998
1999     ff_read_frame_flush(s);
2000     if (s->iformat->read_seek){
2001         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2002             return 0;
2003     }
2004     ie = &st->index_entries[index];
2005     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2006         return ret;
2007     ff_update_cur_dts(s, st, ie->timestamp);
2008
2009     return 0;
2010 }
2011
2012 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2013                                int64_t timestamp, int flags)
2014 {
2015     int ret;
2016     AVStream *st;
2017
2018     if (flags & AVSEEK_FLAG_BYTE) {
2019         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2020             return -1;
2021         ff_read_frame_flush(s);
2022         return seek_frame_byte(s, stream_index, timestamp, flags);
2023     }
2024
2025     if(stream_index < 0){
2026         stream_index= av_find_default_stream_index(s);
2027         if(stream_index < 0)
2028             return -1;
2029
2030         st= s->streams[stream_index];
2031         /* timestamp for default must be expressed in AV_TIME_BASE units */
2032         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2033     }
2034
2035     /* first, we try the format specific seek */
2036     if (s->iformat->read_seek) {
2037         ff_read_frame_flush(s);
2038         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2039     } else
2040         ret = -1;
2041     if (ret >= 0) {
2042         return 0;
2043     }
2044
2045     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2046         ff_read_frame_flush(s);
2047         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2048     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2049         ff_read_frame_flush(s);
2050         return seek_frame_generic(s, stream_index, timestamp, flags);
2051     }
2052     else
2053         return -1;
2054 }
2055
2056 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2057 {
2058     int ret;
2059
2060     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2061         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2062         if ((flags & AVSEEK_FLAG_BACKWARD))
2063             max_ts = timestamp;
2064         else
2065             min_ts = timestamp;
2066         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2067                                   flags & ~AVSEEK_FLAG_BACKWARD);
2068     }
2069
2070     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2071
2072     if (ret >= 0)
2073         ret = avformat_queue_attached_pictures(s);
2074
2075     return ret;
2076 }
2077
2078 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2079 {
2080     if(min_ts > ts || max_ts < ts)
2081         return -1;
2082     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2083         return AVERROR(EINVAL);
2084
2085     if(s->seek2any>0)
2086         flags |= AVSEEK_FLAG_ANY;
2087     flags &= ~AVSEEK_FLAG_BACKWARD;
2088
2089     if (s->iformat->read_seek2) {
2090         int ret;
2091         ff_read_frame_flush(s);
2092
2093         if (stream_index == -1 && s->nb_streams == 1) {
2094             AVRational time_base = s->streams[0]->time_base;
2095             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2096             min_ts = av_rescale_rnd(min_ts, time_base.den,
2097                                     time_base.num * (int64_t)AV_TIME_BASE,
2098                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2099             max_ts = av_rescale_rnd(max_ts, time_base.den,
2100                                     time_base.num * (int64_t)AV_TIME_BASE,
2101                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2102         }
2103
2104         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2105
2106         if (ret >= 0)
2107             ret = avformat_queue_attached_pictures(s);
2108         return ret;
2109     }
2110
2111     if(s->iformat->read_timestamp){
2112         //try to seek via read_timestamp()
2113     }
2114
2115     // Fall back on old API if new is not implemented but old is.
2116     // Note the old API has somewhat different semantics.
2117     if (s->iformat->read_seek || 1) {
2118         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2119         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2120         if (ret<0 && ts != min_ts && max_ts != ts) {
2121             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2122             if (ret >= 0)
2123                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2124         }
2125         return ret;
2126     }
2127
2128     // try some generic seek like seek_frame_generic() but with new ts semantics
2129     return -1; //unreachable
2130 }
2131
2132 /*******************************************************/
2133
2134 /**
2135  * Return TRUE if the stream has accurate duration in any stream.
2136  *
2137  * @return TRUE if the stream has accurate duration for at least one component.
2138  */
2139 static int has_duration(AVFormatContext *ic)
2140 {
2141     int i;
2142     AVStream *st;
2143
2144     for(i = 0;i < ic->nb_streams; i++) {
2145         st = ic->streams[i];
2146         if (st->duration != AV_NOPTS_VALUE)
2147             return 1;
2148     }
2149     if (ic->duration != AV_NOPTS_VALUE)
2150         return 1;
2151     return 0;
2152 }
2153
2154 /**
2155  * Estimate the stream timings from the one of each components.
2156  *
2157  * Also computes the global bitrate if possible.
2158  */
2159 static void update_stream_timings(AVFormatContext *ic)
2160 {
2161     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2162     int64_t duration, duration1, filesize;
2163     int i;
2164     AVStream *st;
2165     AVProgram *p;
2166
2167     start_time = INT64_MAX;
2168     start_time_text = INT64_MAX;
2169     end_time = INT64_MIN;
2170     duration = INT64_MIN;
2171     for(i = 0;i < ic->nb_streams; i++) {
2172         st = ic->streams[i];
2173         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2174             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2175             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2176                 if (start_time1 < start_time_text)
2177                     start_time_text = start_time1;
2178             } else
2179                 start_time = FFMIN(start_time, start_time1);
2180             end_time1 = AV_NOPTS_VALUE;
2181             if (st->duration != AV_NOPTS_VALUE) {
2182                 end_time1 = start_time1
2183                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2184                 end_time = FFMAX(end_time, end_time1);
2185             }
2186             for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2187                 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2188                     p->start_time = start_time1;
2189                 if(p->end_time < end_time1)
2190                     p->end_time = end_time1;
2191             }
2192         }
2193         if (st->duration != AV_NOPTS_VALUE) {
2194             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2195             duration = FFMAX(duration, duration1);
2196         }
2197     }
2198     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2199         start_time = start_time_text;
2200     else if(start_time > start_time_text)
2201         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2202
2203     if (start_time != INT64_MAX) {
2204         ic->start_time = start_time;
2205         if (end_time != INT64_MIN) {
2206             if (ic->nb_programs) {
2207                 for (i=0; i<ic->nb_programs; i++) {
2208                     p = ic->programs[i];
2209                     if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2210                         duration = FFMAX(duration, p->end_time - p->start_time);
2211                 }
2212             } else
2213                 duration = FFMAX(duration, end_time - start_time);
2214         }
2215     }
2216     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2217         ic->duration = duration;
2218     }
2219         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2220             /* compute the bitrate */
2221             double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2222                 (double)ic->duration;
2223             if (bitrate >= 0 && bitrate <= INT_MAX)
2224                 ic->bit_rate = bitrate;
2225         }
2226 }
2227
2228 static void fill_all_stream_timings(AVFormatContext *ic)
2229 {
2230     int i;
2231     AVStream *st;
2232
2233     update_stream_timings(ic);
2234     for(i = 0;i < ic->nb_streams; i++) {
2235         st = ic->streams[i];
2236         if (st->start_time == AV_NOPTS_VALUE) {
2237             if(ic->start_time != AV_NOPTS_VALUE)
2238                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2239             if(ic->duration != AV_NOPTS_VALUE)
2240                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2241         }
2242     }
2243 }
2244
2245 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2246 {
2247     int64_t filesize, duration;
2248     int i, show_warning = 0;
2249     AVStream *st;
2250
2251     /* if bit_rate is already set, we believe it */
2252     if (ic->bit_rate <= 0) {
2253         int bit_rate = 0;
2254         for(i=0;i<ic->nb_streams;i++) {
2255             st = ic->streams[i];
2256             if (st->codec->bit_rate > 0) {
2257                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2258                     bit_rate = 0;
2259                     break;
2260                 }
2261                 bit_rate += st->codec->bit_rate;
2262             }
2263         }
2264         ic->bit_rate = bit_rate;
2265     }
2266
2267     /* if duration is already set, we believe it */
2268     if (ic->duration == AV_NOPTS_VALUE &&
2269         ic->bit_rate != 0) {
2270         filesize = ic->pb ? avio_size(ic->pb) : 0;
2271         if (filesize > 0) {
2272             for(i = 0; i < ic->nb_streams; i++) {
2273                 st = ic->streams[i];
2274                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2275                     && st->duration == AV_NOPTS_VALUE) {
2276                     duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2277                     st->duration = duration;
2278                     show_warning = 1;
2279                 }
2280             }
2281         }
2282     }
2283     if (show_warning)
2284         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2285 }
2286
2287 #define DURATION_MAX_READ_SIZE 250000LL
2288 #define DURATION_MAX_RETRY 4
2289
2290 /* only usable for MPEG-PS streams */
2291 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2292 {
2293     AVPacket pkt1, *pkt = &pkt1;
2294     AVStream *st;
2295     int read_size, i, ret;
2296     int64_t end_time;
2297     int64_t filesize, offset, duration;
2298     int retry=0;
2299
2300     /* flush packet queue */
2301     flush_packet_queue(ic);
2302
2303     for (i=0; i<ic->nb_streams; i++) {
2304         st = ic->streams[i];
2305         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2306             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2307
2308         if (st->parser) {
2309             av_parser_close(st->parser);
2310             st->parser= NULL;
2311         }
2312     }
2313
2314     /* estimate the end time (duration) */
2315     /* XXX: may need to support wrapping */
2316     filesize = ic->pb ? avio_size(ic->pb) : 0;
2317     end_time = AV_NOPTS_VALUE;
2318     do{
2319         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2320         if (offset < 0)
2321             offset = 0;
2322
2323         avio_seek(ic->pb, offset, SEEK_SET);
2324         read_size = 0;
2325         for(;;) {
2326             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2327                 break;
2328
2329             do {
2330                 ret = ff_read_packet(ic, pkt);
2331             } while(ret == AVERROR(EAGAIN));
2332             if (ret != 0)
2333                 break;
2334             read_size += pkt->size;
2335             st = ic->streams[pkt->stream_index];
2336             if (pkt->pts != AV_NOPTS_VALUE &&
2337                 (st->start_time != AV_NOPTS_VALUE ||
2338                  st->first_dts  != AV_NOPTS_VALUE)) {
2339                 duration = end_time = pkt->pts;
2340                 if (st->start_time != AV_NOPTS_VALUE)
2341                     duration -= st->start_time;
2342                 else
2343                     duration -= st->first_dts;
2344                 if (duration > 0) {
2345                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2346                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2347                         st->duration = duration;
2348                     st->info->last_duration = duration;
2349                 }
2350             }
2351             av_free_packet(pkt);
2352         }
2353     }while(   end_time==AV_NOPTS_VALUE
2354            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2355            && ++retry <= DURATION_MAX_RETRY);
2356
2357     fill_all_stream_timings(ic);
2358
2359     avio_seek(ic->pb, old_offset, SEEK_SET);
2360     for (i=0; i<ic->nb_streams; i++) {
2361         st= ic->streams[i];
2362         st->cur_dts= st->first_dts;
2363         st->last_IP_pts = AV_NOPTS_VALUE;
2364     }
2365 }
2366
2367 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2368 {
2369     int64_t file_size;
2370
2371     /* get the file size, if possible */
2372     if (ic->iformat->flags & AVFMT_NOFILE) {
2373         file_size = 0;
2374     } else {
2375         file_size = avio_size(ic->pb);
2376         file_size = FFMAX(0, file_size);
2377     }
2378
2379     if ((!strcmp(ic->iformat->name, "mpeg") ||
2380          !strcmp(ic->iformat->name, "mpegts")) &&
2381         file_size && ic->pb->seekable) {
2382         /* get accurate estimate from the PTSes */
2383         estimate_timings_from_pts(ic, old_offset);
2384         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2385     } else if (has_duration(ic)) {
2386         /* at least one component has timings - we use them for all
2387            the components */
2388         fill_all_stream_timings(ic);
2389         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2390     } else {
2391         /* less precise: use bitrate info */
2392         estimate_timings_from_bit_rate(ic);
2393         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2394     }
2395     update_stream_timings(ic);
2396
2397     {
2398         int i;
2399         AVStream av_unused *st;
2400         for(i = 0;i < ic->nb_streams; i++) {
2401             st = ic->streams[i];
2402             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2403                     (double) st->start_time / AV_TIME_BASE,
2404                     (double) st->duration   / AV_TIME_BASE);
2405         }
2406         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2407                 (double) ic->start_time / AV_TIME_BASE,
2408                 (double) ic->duration   / AV_TIME_BASE,
2409                 ic->bit_rate / 1000);
2410     }
2411 }
2412
2413 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2414 {
2415     AVCodecContext *avctx = st->codec;
2416
2417 #define FAIL(errmsg) do {                                         \
2418         if (errmsg_ptr)                                           \
2419             *errmsg_ptr = errmsg;                                 \
2420         return 0;                                                 \
2421     } while (0)
2422
2423     switch (avctx->codec_type) {
2424     case AVMEDIA_TYPE_AUDIO:
2425         if (!avctx->frame_size && determinable_frame_size(avctx))
2426             FAIL("unspecified frame size");
2427         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2428             FAIL("unspecified sample format");
2429         if (!avctx->sample_rate)
2430             FAIL("unspecified sample rate");
2431         if (!avctx->channels)
2432             FAIL("unspecified number of channels");
2433         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2434             FAIL("no decodable DTS frames");
2435         break;
2436     case AVMEDIA_TYPE_VIDEO:
2437         if (!avctx->width)
2438             FAIL("unspecified size");
2439         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2440             FAIL("unspecified pixel format");
2441         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2442             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2443                 FAIL("no frame in rv30/40 and no sar");
2444         break;
2445     case AVMEDIA_TYPE_SUBTITLE:
2446         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2447             FAIL("unspecified size");
2448         break;
2449     case AVMEDIA_TYPE_DATA:
2450         if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2451     }
2452
2453     if (avctx->codec_id == AV_CODEC_ID_NONE)
2454         FAIL("unknown codec");
2455     return 1;
2456 }
2457
2458 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2459 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
2460 {
2461     const AVCodec *codec;
2462     int got_picture = 1, ret = 0;
2463     AVFrame *frame = av_frame_alloc();
2464     AVSubtitle subtitle;
2465     AVPacket pkt = *avpkt;
2466
2467     if (!frame)
2468         return AVERROR(ENOMEM);
2469
2470     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2471         AVDictionary *thread_opt = NULL;
2472
2473         codec = find_decoder(s, st, st->codec->codec_id);
2474
2475         if (!codec) {
2476             st->info->found_decoder = -1;
2477             ret = -1;
2478             goto fail;
2479         }
2480
2481         /* force thread count to 1 since the h264 decoder will not extract SPS
2482          *  and PPS to extradata during multi-threaded decoding */
2483         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2484         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2485         if (!options)
2486             av_dict_free(&thread_opt);
2487         if (ret < 0) {
2488             st->info->found_decoder = -1;
2489             goto fail;
2490         }
2491         st->info->found_decoder = 1;
2492     } else if (!st->info->found_decoder)
2493         st->info->found_decoder = 1;
2494
2495     if (st->info->found_decoder < 0) {
2496         ret = -1;
2497         goto fail;
2498     }
2499
2500     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2501            ret >= 0 &&
2502            (!has_codec_parameters(st, NULL)   ||
2503            !has_decode_delay_been_guessed(st) ||
2504            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2505         got_picture = 0;
2506         avcodec_get_frame_defaults(frame);
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     avcodec_free_frame(&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
2735         if (st->info->duration_count % 10 == 0) {
2736             int n = st->info->duration_count;
2737             for (i=0; i<MAX_STD_TIMEBASES; i++) {
2738                 if (st->info->duration_error[0][1][i] < 1e10) {
2739                     double a0     = st->info->duration_error[0][0][i] / n;
2740                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2741                     double a1     = st->info->duration_error[1][0][i] / n;
2742                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2743                     if (error0 > 0.04 && error1 > 0.04) {
2744                         st->info->duration_error[0][1][i] = 2e10;
2745                         st->info->duration_error[1][1][i] = 2e10;
2746                     }
2747                 }
2748             }
2749         }
2750
2751         // ignore the first 4 values, they might have some random jitter
2752         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2753             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2754     }
2755     if (ts != AV_NOPTS_VALUE)
2756         st->info->last_dts = ts;
2757
2758     return 0;
2759 }
2760
2761 void ff_rfps_calculate(AVFormatContext *ic)
2762 {
2763     int i, j;
2764
2765     for (i = 0; i<ic->nb_streams; i++) {
2766         AVStream *st = ic->streams[i];
2767
2768         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2769             continue;
2770         // the check for tb_unreliable() is not completely correct, since this is not about handling
2771         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2772         // ipmovie.c produces.
2773         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)
2774             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);
2775         if (st->info->duration_count>1 && !st->r_frame_rate.num
2776             && tb_unreliable(st->codec)) {
2777             int num = 0;
2778             double best_error= 0.01;
2779
2780             for (j=0; j<MAX_STD_TIMEBASES; j++) {
2781                 int k;
2782
2783                 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2784                     continue;
2785                 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2786                     continue;
2787                 for(k=0; k<2; k++){
2788                     int n= st->info->duration_count;
2789                     double a= st->info->duration_error[k][0][j] / n;
2790                     double error= st->info->duration_error[k][1][j]/n - a*a;
2791
2792                     if(error < best_error && best_error> 0.000000001){
2793                         best_error= error;
2794                         num = get_std_framerate(j);
2795                     }
2796                     if(error < 0.02)
2797                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2798                 }
2799             }
2800             // do not increase frame rate by more than 1 % in order to match a standard rate.
2801             if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2802                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2803         }
2804
2805         av_freep(&st->info->duration_error);
2806         st->info->last_dts = AV_NOPTS_VALUE;
2807         st->info->duration_count = 0;
2808     }
2809 }
2810
2811 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2812 {
2813     int i, count, ret = 0, j;
2814     int64_t read_size;
2815     AVStream *st;
2816     AVPacket pkt1, *pkt;
2817     int64_t old_offset = avio_tell(ic->pb);
2818     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2819     int flush_codecs = ic->probesize > 0;
2820
2821     if(ic->pb)
2822         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2823                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2824
2825     for(i=0;i<ic->nb_streams;i++) {
2826         const AVCodec *codec;
2827         AVDictionary *thread_opt = NULL;
2828         st = ic->streams[i];
2829
2830         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2831             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2832 /*            if(!st->time_base.num)
2833                 st->time_base= */
2834             if(!st->codec->time_base.num)
2835                 st->codec->time_base= st->time_base;
2836         }
2837         //only for the split stuff
2838         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2839             st->parser = av_parser_init(st->codec->codec_id);
2840             if(st->parser){
2841                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2842                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2843                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2844                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2845                 }
2846             } else if (st->need_parsing) {
2847                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2848                        "%s, packets or times may be invalid.\n",
2849                        avcodec_get_name(st->codec->codec_id));
2850             }
2851         }
2852         codec = find_decoder(ic, st, st->codec->codec_id);
2853
2854         /* force thread count to 1 since the h264 decoder will not extract SPS
2855          *  and PPS to extradata during multi-threaded decoding */
2856         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2857
2858         /* Ensure that subtitle_header is properly set. */
2859         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2860             && codec && !st->codec->codec)
2861             avcodec_open2(st->codec, codec, options ? &options[i]
2862                               : &thread_opt);
2863
2864         //try to just open decoders, in case this is enough to get parameters
2865         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2866             if (codec && !st->codec->codec)
2867                 avcodec_open2(st->codec, codec, options ? &options[i]
2868                               : &thread_opt);
2869         }
2870         if (!options)
2871             av_dict_free(&thread_opt);
2872     }
2873
2874     for (i=0; i<ic->nb_streams; i++) {
2875 #if FF_API_R_FRAME_RATE
2876         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2877 #endif
2878         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2879         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2880     }
2881
2882     count = 0;
2883     read_size = 0;
2884     for(;;) {
2885         if (ff_check_interrupt(&ic->interrupt_callback)){
2886             ret= AVERROR_EXIT;
2887             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2888             break;
2889         }
2890
2891         /* check if one codec still needs to be handled */
2892         for(i=0;i<ic->nb_streams;i++) {
2893             int fps_analyze_framecount = 20;
2894
2895             st = ic->streams[i];
2896             if (!has_codec_parameters(st, NULL))
2897                 break;
2898             /* if the timebase is coarse (like the usual millisecond precision
2899                of mkv), we need to analyze more frames to reliably arrive at
2900                the correct fps */
2901             if (av_q2d(st->time_base) > 0.0005)
2902                 fps_analyze_framecount *= 2;
2903             if (ic->fps_probe_size >= 0)
2904                 fps_analyze_framecount = ic->fps_probe_size;
2905             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2906                 fps_analyze_framecount = 0;
2907             /* variable fps and no guess at the real fps */
2908             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2909                && st->info->duration_count < fps_analyze_framecount
2910                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2911                 break;
2912             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2913                 break;
2914             if (st->first_dts == AV_NOPTS_VALUE &&
2915                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2916                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2917                 break;
2918         }
2919         if (i == ic->nb_streams) {
2920             /* NOTE: if the format has no header, then we need to read
2921                some packets to get most of the streams, so we cannot
2922                stop here */
2923             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2924                 /* if we found the info for all the codecs, we can stop */
2925                 ret = count;
2926                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2927                 flush_codecs = 0;
2928                 break;
2929             }
2930         }
2931         /* we did not get all the codec info, but we read too much data */
2932         if (read_size >= ic->probesize) {
2933             ret = count;
2934             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2935             for (i = 0; i < ic->nb_streams; i++)
2936                 if (!ic->streams[i]->r_frame_rate.num &&
2937                     ic->streams[i]->info->duration_count <= 1 &&
2938                     strcmp(ic->iformat->name, "image2"))
2939                     av_log(ic, AV_LOG_WARNING,
2940                            "Stream #%d: not enough frames to estimate rate; "
2941                            "consider increasing probesize\n", i);
2942             break;
2943         }
2944
2945         /* NOTE: a new stream can be added there if no header in file
2946            (AVFMTCTX_NOHEADER) */
2947         ret = read_frame_internal(ic, &pkt1);
2948         if (ret == AVERROR(EAGAIN))
2949             continue;
2950
2951         if (ret < 0) {
2952             /* EOF or error*/
2953             break;
2954         }
2955
2956         if (ic->flags & AVFMT_FLAG_NOBUFFER)
2957             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2958         {
2959             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2960                                 &ic->packet_buffer_end);
2961             if (!pkt) {
2962                 ret = AVERROR(ENOMEM);
2963                 goto find_stream_info_err;
2964             }
2965             if ((ret = av_dup_packet(pkt)) < 0)
2966                 goto find_stream_info_err;
2967         }
2968
2969         st = ic->streams[pkt->stream_index];
2970         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2971             read_size += pkt->size;
2972
2973         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2974             /* check for non-increasing dts */
2975             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2976                 st->info->fps_last_dts >= pkt->dts) {
2977                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2978                        "packet %d with DTS %"PRId64", packet %d with DTS "
2979                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2980                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2981                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2982             }
2983             /* check for a discontinuity in dts - if the difference in dts
2984              * is more than 1000 times the average packet duration in the sequence,
2985              * we treat it as a discontinuity */
2986             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2987                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2988                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2989                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2990                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2991                        "packet %d with DTS %"PRId64", packet %d with DTS "
2992                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2993                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2994                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2995             }
2996
2997             /* update stored dts values */
2998             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2999                 st->info->fps_first_dts     = pkt->dts;
3000                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3001             }
3002             st->info->fps_last_dts = pkt->dts;
3003             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3004         }
3005         if (st->codec_info_nb_frames>1) {
3006             int64_t t=0;
3007             if (st->time_base.den > 0)
3008                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3009             if (st->avg_frame_rate.num > 0)
3010                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3011
3012             if (   t==0
3013                 && st->codec_info_nb_frames>30
3014                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3015                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3016                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3017
3018             if (t >= ic->max_analyze_duration) {
3019                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
3020                 break;
3021             }
3022             if (pkt->duration) {
3023                 st->info->codec_info_duration        += pkt->duration;
3024                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
3025             }
3026         }
3027 #if FF_API_R_FRAME_RATE
3028         ff_rfps_add_frame(ic, st, pkt->dts);
3029 #endif
3030         if(st->parser && st->parser->parser->split && !st->codec->extradata){
3031             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
3032             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3033                 if (ff_alloc_extradata(st->codec, i))
3034                     return AVERROR(ENOMEM);
3035                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
3036             }
3037         }
3038
3039         /* if still no information, we try to open the codec and to
3040            decompress the frame. We try to avoid that in most cases as
3041            it takes longer and uses more memory. For MPEG-4, we need to
3042            decompress for QuickTime.
3043
3044            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3045            least one frame of codec data, this makes sure the codec initializes
3046            the channel configuration and does not only trust the values from the container.
3047         */
3048         try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
3049
3050         st->codec_info_nb_frames++;
3051         count++;
3052     }
3053
3054     if (flush_codecs) {
3055         AVPacket empty_pkt = { 0 };
3056         int err = 0;
3057         av_init_packet(&empty_pkt);
3058
3059         for(i=0;i<ic->nb_streams;i++) {
3060
3061             st = ic->streams[i];
3062
3063             /* flush the decoders */
3064             if (st->info->found_decoder == 1) {
3065                 do {
3066                     err = try_decode_frame(ic, st, &empty_pkt,
3067                                             (options && i < orig_nb_streams) ?
3068                                             &options[i] : NULL);
3069                 } while (err > 0 && !has_codec_parameters(st, NULL));
3070
3071                 if (err < 0) {
3072                     av_log(ic, AV_LOG_INFO,
3073                         "decoding for stream %d failed\n", st->index);
3074                 }
3075             }
3076         }
3077     }
3078
3079     // close codecs which were opened in try_decode_frame()
3080     for(i=0;i<ic->nb_streams;i++) {
3081         st = ic->streams[i];
3082         avcodec_close(st->codec);
3083     }
3084
3085     ff_rfps_calculate(ic);
3086
3087     for(i=0;i<ic->nb_streams;i++) {
3088         st = ic->streams[i];
3089         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3090             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3091                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3092                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3093                     st->codec->codec_tag= tag;
3094             }
3095
3096             /* estimate average framerate if not set by demuxer */
3097             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3098                 int      best_fps = 0;
3099                 double best_error = 0.01;
3100
3101                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3102                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3103                     st->info->codec_info_duration        < 0)
3104                     continue;
3105                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3106                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3107                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3108
3109                 /* round guessed framerate to a "standard" framerate if it's
3110                  * within 1% of the original estimate*/
3111                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3112                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
3113                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3114
3115                     if (error < best_error) {
3116                         best_error = error;
3117                         best_fps   = std_fps.num;
3118                     }
3119                 }
3120                 if (best_fps) {
3121                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3122                               best_fps, 12*1001, INT_MAX);
3123                 }
3124             }
3125
3126             if (!st->r_frame_rate.num){
3127                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3128                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3129                     st->r_frame_rate.num = st->codec->time_base.den;
3130                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3131                 }else{
3132                     st->r_frame_rate.num = st->time_base.den;
3133                     st->r_frame_rate.den = st->time_base.num;
3134                 }
3135             }
3136         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3137             if(!st->codec->bits_per_coded_sample)
3138                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3139             // set stream disposition based on audio service type
3140             switch (st->codec->audio_service_type) {
3141             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3142                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3143             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3144                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3145             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3146                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3147             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3148                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3149             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3150                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3151             }
3152         }
3153     }
3154
3155     if(ic->probesize)
3156     estimate_timings(ic, old_offset);
3157
3158     if (ret >= 0 && ic->nb_streams)
3159         ret = -1; /* we could not have all the codec parameters before EOF */
3160     for(i=0;i<ic->nb_streams;i++) {
3161         const char *errmsg;
3162         st = ic->streams[i];
3163         if (!has_codec_parameters(st, &errmsg)) {
3164             char buf[256];
3165             avcodec_string(buf, sizeof(buf), st->codec, 0);
3166             av_log(ic, AV_LOG_WARNING,
3167                    "Could not find codec parameters for stream %d (%s): %s\n"
3168                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3169                    i, buf, errmsg);
3170         } else {
3171             ret = 0;
3172         }
3173     }
3174
3175     compute_chapters_end(ic);
3176
3177  find_stream_info_err:
3178     for (i=0; i < ic->nb_streams; i++) {
3179         st = ic->streams[i];
3180         if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3181             ic->streams[i]->codec->thread_count = 0;
3182         if (st->info)
3183             av_freep(&st->info->duration_error);
3184         av_freep(&ic->streams[i]->info);
3185     }
3186     if(ic->pb)
3187         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3188                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3189     return ret;
3190 }
3191
3192 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3193 {
3194     int i, j;
3195
3196     for (i = 0; i < ic->nb_programs; i++) {
3197         if (ic->programs[i] == last) {
3198             last = NULL;
3199         } else {
3200             if (!last)
3201                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3202                     if (ic->programs[i]->stream_index[j] == s)
3203                         return ic->programs[i];
3204         }
3205     }
3206     return NULL;
3207 }
3208
3209 int av_find_best_stream(AVFormatContext *ic,
3210                         enum AVMediaType type,
3211                         int wanted_stream_nb,
3212                         int related_stream,
3213                         AVCodec **decoder_ret,
3214                         int flags)
3215 {
3216     int i, nb_streams = ic->nb_streams;
3217     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3218     unsigned *program = NULL;
3219     AVCodec *decoder = NULL, *best_decoder = NULL;
3220
3221     if (related_stream >= 0 && wanted_stream_nb < 0) {
3222         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3223         if (p) {
3224             program = p->stream_index;
3225             nb_streams = p->nb_stream_indexes;
3226         }
3227     }
3228     for (i = 0; i < nb_streams; i++) {
3229         int real_stream_index = program ? program[i] : i;
3230         AVStream *st = ic->streams[real_stream_index];
3231         AVCodecContext *avctx = st->codec;
3232         if (avctx->codec_type != type)
3233             continue;
3234         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3235             continue;
3236         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3237             continue;
3238         if (decoder_ret) {
3239             decoder = find_decoder(ic, st, st->codec->codec_id);
3240             if (!decoder) {
3241                 if (ret < 0)
3242                     ret = AVERROR_DECODER_NOT_FOUND;
3243                 continue;
3244             }
3245         }
3246         count = st->codec_info_nb_frames;
3247         bitrate = avctx->bit_rate;
3248         multiframe = FFMIN(5, count);
3249         if ((best_multiframe >  multiframe) ||
3250             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3251             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3252             continue;
3253         best_count = count;
3254         best_bitrate = bitrate;
3255         best_multiframe = multiframe;
3256         ret = real_stream_index;
3257         best_decoder = decoder;
3258         if (program && i == nb_streams - 1 && ret < 0) {
3259             program = NULL;
3260             nb_streams = ic->nb_streams;
3261             i = 0; /* no related stream found, try again with everything */
3262         }
3263     }
3264     if (decoder_ret)
3265         *decoder_ret = best_decoder;
3266     return ret;
3267 }
3268
3269 /*******************************************************/
3270
3271 int av_read_play(AVFormatContext *s)
3272 {
3273     if (s->iformat->read_play)
3274         return s->iformat->read_play(s);
3275     if (s->pb)
3276         return avio_pause(s->pb, 0);
3277     return AVERROR(ENOSYS);
3278 }
3279
3280 int av_read_pause(AVFormatContext *s)
3281 {
3282     if (s->iformat->read_pause)
3283         return s->iformat->read_pause(s);
3284     if (s->pb)
3285         return avio_pause(s->pb, 1);
3286     return AVERROR(ENOSYS);
3287 }
3288
3289 void ff_free_stream(AVFormatContext *s, AVStream *st){
3290     av_assert0(s->nb_streams>0);
3291     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3292
3293     if (st->parser) {
3294         av_parser_close(st->parser);
3295     }
3296     if (st->attached_pic.data)
3297         av_free_packet(&st->attached_pic);
3298     av_dict_free(&st->metadata);
3299     av_freep(&st->probe_data.buf);
3300     av_freep(&st->index_entries);
3301     av_freep(&st->codec->extradata);
3302     av_freep(&st->codec->subtitle_header);
3303     av_freep(&st->codec);
3304     av_freep(&st->priv_data);
3305     if (st->info)
3306         av_freep(&st->info->duration_error);
3307     av_freep(&st->info);
3308     av_freep(&s->streams[ --s->nb_streams ]);
3309 }
3310
3311 void avformat_free_context(AVFormatContext *s)
3312 {
3313     int i;
3314
3315     if (!s)
3316         return;
3317
3318     av_opt_free(s);
3319     if (s->iformat && s->iformat->priv_class && s->priv_data)
3320         av_opt_free(s->priv_data);
3321
3322     for(i=s->nb_streams-1; i>=0; i--) {
3323         ff_free_stream(s, s->streams[i]);
3324     }
3325     for(i=s->nb_programs-1; i>=0; i--) {
3326         av_dict_free(&s->programs[i]->metadata);
3327         av_freep(&s->programs[i]->stream_index);
3328         av_freep(&s->programs[i]);
3329     }
3330     av_freep(&s->programs);
3331     av_freep(&s->priv_data);
3332     while(s->nb_chapters--) {
3333         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3334         av_freep(&s->chapters[s->nb_chapters]);
3335     }
3336     av_freep(&s->chapters);
3337     av_dict_free(&s->metadata);
3338     av_freep(&s->streams);
3339     av_free(s);
3340 }
3341
3342 #if FF_API_CLOSE_INPUT_FILE
3343 void av_close_input_file(AVFormatContext *s)
3344 {
3345     avformat_close_input(&s);
3346 }
3347 #endif
3348
3349 void avformat_close_input(AVFormatContext **ps)
3350 {
3351     AVFormatContext *s;
3352     AVIOContext *pb;
3353
3354     if (!ps || !*ps)
3355         return;
3356
3357     s = *ps;
3358     pb = s->pb;
3359
3360     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3361         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3362         pb = NULL;
3363
3364     flush_packet_queue(s);
3365
3366     if (s->iformat) {
3367         if (s->iformat->read_close)
3368             s->iformat->read_close(s);
3369     }
3370
3371     avformat_free_context(s);
3372
3373     *ps = NULL;
3374
3375     avio_close(pb);
3376 }
3377
3378 #if FF_API_NEW_STREAM
3379 AVStream *av_new_stream(AVFormatContext *s, int id)
3380 {
3381     AVStream *st = avformat_new_stream(s, NULL);
3382     if (st)
3383         st->id = id;
3384     return st;
3385 }
3386 #endif
3387
3388 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3389 {
3390     AVStream *st;
3391     int i;
3392     AVStream **streams;
3393
3394     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3395         return NULL;
3396     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3397     if (!streams)
3398         return NULL;
3399     s->streams = streams;
3400
3401     st = av_mallocz(sizeof(AVStream));
3402     if (!st)
3403         return NULL;
3404     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3405         av_free(st);
3406         return NULL;
3407     }
3408     st->info->last_dts = AV_NOPTS_VALUE;
3409
3410     st->codec = avcodec_alloc_context3(c);
3411     if (s->iformat) {
3412         /* no default bitrate if decoding */
3413         st->codec->bit_rate = 0;
3414     }
3415     st->index = s->nb_streams;
3416     st->start_time = AV_NOPTS_VALUE;
3417     st->duration = AV_NOPTS_VALUE;
3418         /* we set the current DTS to 0 so that formats without any timestamps
3419            but durations get some timestamps, formats with some unknown
3420            timestamps have their first few packets buffered and the
3421            timestamps corrected before they are returned to the user */
3422     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3423     st->first_dts = AV_NOPTS_VALUE;
3424     st->probe_packets = MAX_PROBE_PACKETS;
3425     st->pts_wrap_reference = AV_NOPTS_VALUE;
3426     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3427
3428     /* default pts setting is MPEG-like */
3429     avpriv_set_pts_info(st, 33, 1, 90000);
3430     st->last_IP_pts = AV_NOPTS_VALUE;
3431     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3432         st->pts_buffer[i]= AV_NOPTS_VALUE;
3433
3434     st->sample_aspect_ratio = (AVRational){0,1};
3435
3436 #if FF_API_R_FRAME_RATE
3437     st->info->last_dts      = AV_NOPTS_VALUE;
3438 #endif
3439     st->info->fps_first_dts = AV_NOPTS_VALUE;
3440     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3441
3442     s->streams[s->nb_streams++] = st;
3443     return st;
3444 }
3445
3446 AVProgram *av_new_program(AVFormatContext *ac, int id)
3447 {
3448     AVProgram *program=NULL;
3449     int i;
3450
3451     av_dlog(ac, "new_program: id=0x%04x\n", id);
3452
3453     for(i=0; i<ac->nb_programs; i++)
3454         if(ac->programs[i]->id == id)
3455             program = ac->programs[i];
3456
3457     if(!program){
3458         program = av_mallocz(sizeof(AVProgram));
3459         if (!program)
3460             return NULL;
3461         dynarray_add(&ac->programs, &ac->nb_programs, program);
3462         program->discard = AVDISCARD_NONE;
3463     }
3464     program->id = id;
3465     program->pts_wrap_reference = AV_NOPTS_VALUE;
3466     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3467
3468     program->start_time =
3469     program->end_time   = AV_NOPTS_VALUE;
3470
3471     return program;
3472 }
3473
3474 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3475 {
3476     AVChapter *chapter = NULL;
3477     int i;
3478
3479     for(i=0; i<s->nb_chapters; i++)
3480         if(s->chapters[i]->id == id)
3481             chapter = s->chapters[i];
3482
3483     if(!chapter){
3484         chapter= av_mallocz(sizeof(AVChapter));
3485         if(!chapter)
3486             return NULL;
3487         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3488     }
3489     av_dict_set(&chapter->metadata, "title", title, 0);
3490     chapter->id    = id;
3491     chapter->time_base= time_base;
3492     chapter->start = start;
3493     chapter->end   = end;
3494
3495     return chapter;
3496 }
3497
3498 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3499 {
3500     int i, j;
3501     AVProgram *program=NULL;
3502     void *tmp;
3503
3504     if (idx >= ac->nb_streams) {
3505         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3506         return;
3507     }
3508
3509     for(i=0; i<ac->nb_programs; i++){
3510         if(ac->programs[i]->id != progid)
3511             continue;
3512         program = ac->programs[i];
3513         for(j=0; j<program->nb_stream_indexes; j++)
3514             if(program->stream_index[j] == idx)
3515                 return;
3516
3517         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3518         if(!tmp)
3519             return;
3520         program->stream_index = tmp;
3521         program->stream_index[program->nb_stream_indexes++] = idx;
3522         return;
3523     }
3524 }
3525
3526 static void print_fps(double d, const char *postfix){
3527     uint64_t v= lrintf(d*100);
3528     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3529     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3530     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3531 }
3532
3533 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3534 {
3535     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3536         AVDictionaryEntry *tag=NULL;
3537
3538         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3539         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3540             if(strcmp("language", tag->key)){
3541                 const char *p = tag->value;
3542                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3543                 while(*p) {
3544                     char tmp[256];
3545                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3546                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3547                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3548                     p += len;
3549                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3550                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3551                     if (*p) p++;
3552                 }
3553                 av_log(ctx, AV_LOG_INFO, "\n");
3554             }
3555         }
3556     }
3557 }
3558
3559 /* "user interface" functions */
3560 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3561 {
3562     char buf[256];
3563     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3564     AVStream *st = ic->streams[i];
3565     int g = av_gcd(st->time_base.num, st->time_base.den);
3566     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3567     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3568     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3569     /* the pid is an important information, so we display it */
3570     /* XXX: add a generic system */
3571     if (flags & AVFMT_SHOW_IDS)
3572         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3573     if (lang)
3574         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3575     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3576     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3577     if (st->sample_aspect_ratio.num && // default
3578         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3579         AVRational display_aspect_ratio;
3580         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3581                   st->codec->width*st->sample_aspect_ratio.num,
3582                   st->codec->height*st->sample_aspect_ratio.den,
3583                   1024*1024);
3584         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3585                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3586                  display_aspect_ratio.num, display_aspect_ratio.den);
3587     }
3588     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3589         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3590             print_fps(av_q2d(st->avg_frame_rate), "fps");
3591 #if FF_API_R_FRAME_RATE
3592         if(st->r_frame_rate.den && st->r_frame_rate.num)
3593             print_fps(av_q2d(st->r_frame_rate), "tbr");
3594 #endif
3595         if(st->time_base.den && st->time_base.num)
3596             print_fps(1/av_q2d(st->time_base), "tbn");
3597         if(st->codec->time_base.den && st->codec->time_base.num)
3598             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3599     }
3600     if (st->disposition & AV_DISPOSITION_DEFAULT)
3601         av_log(NULL, AV_LOG_INFO, " (default)");
3602     if (st->disposition & AV_DISPOSITION_DUB)
3603         av_log(NULL, AV_LOG_INFO, " (dub)");
3604     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3605         av_log(NULL, AV_LOG_INFO, " (original)");
3606     if (st->disposition & AV_DISPOSITION_COMMENT)
3607         av_log(NULL, AV_LOG_INFO, " (comment)");
3608     if (st->disposition & AV_DISPOSITION_LYRICS)
3609         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3610     if (st->disposition & AV_DISPOSITION_KARAOKE)
3611         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3612     if (st->disposition & AV_DISPOSITION_FORCED)
3613         av_log(NULL, AV_LOG_INFO, " (forced)");
3614     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3615         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3616     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3617         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3618     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3619         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3620     av_log(NULL, AV_LOG_INFO, "\n");
3621     dump_metadata(NULL, st->metadata, "    ");
3622 }
3623
3624 void av_dump_format(AVFormatContext *ic,
3625                     int index,
3626                     const char *url,
3627                     int is_output)
3628 {
3629     int i;
3630     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3631     if (ic->nb_streams && !printed)
3632         return;
3633
3634     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3635             is_output ? "Output" : "Input",
3636             index,
3637             is_output ? ic->oformat->name : ic->iformat->name,
3638             is_output ? "to" : "from", url);
3639     dump_metadata(NULL, ic->metadata, "  ");
3640     if (!is_output) {
3641         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3642         if (ic->duration != AV_NOPTS_VALUE) {
3643             int hours, mins, secs, us;
3644             int64_t duration = ic->duration + 5000;
3645             secs = duration / AV_TIME_BASE;
3646             us = duration % AV_TIME_BASE;
3647             mins = secs / 60;
3648             secs %= 60;
3649             hours = mins / 60;
3650             mins %= 60;
3651             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3652                    (100 * us) / AV_TIME_BASE);
3653         } else {
3654             av_log(NULL, AV_LOG_INFO, "N/A");
3655         }
3656         if (ic->start_time != AV_NOPTS_VALUE) {
3657             int secs, us;
3658             av_log(NULL, AV_LOG_INFO, ", start: ");
3659             secs = ic->start_time / AV_TIME_BASE;
3660             us = abs(ic->start_time % AV_TIME_BASE);
3661             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3662                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3663         }
3664         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3665         if (ic->bit_rate) {
3666             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3667         } else {
3668             av_log(NULL, AV_LOG_INFO, "N/A");
3669         }
3670         av_log(NULL, AV_LOG_INFO, "\n");
3671     }
3672     for (i = 0; i < ic->nb_chapters; i++) {
3673         AVChapter *ch = ic->chapters[i];
3674         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3675         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3676         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3677
3678         dump_metadata(NULL, ch->metadata, "    ");
3679     }
3680     if(ic->nb_programs) {
3681         int j, k, total = 0;
3682         for(j=0; j<ic->nb_programs; j++) {
3683             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3684                                                   "name", NULL, 0);
3685             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3686                    name ? name->value : "");
3687             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3688             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3689                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3690                 printed[ic->programs[j]->stream_index[k]] = 1;
3691             }
3692             total += ic->programs[j]->nb_stream_indexes;
3693         }
3694         if (total < ic->nb_streams)
3695             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3696     }
3697     for(i=0;i<ic->nb_streams;i++)
3698         if (!printed[i])
3699             dump_stream_format(ic, i, index, is_output);
3700
3701     av_free(printed);
3702 }
3703
3704 uint64_t ff_ntp_time(void)
3705 {
3706   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3707 }
3708
3709 int av_get_frame_filename(char *buf, int buf_size,
3710                           const char *path, int number)
3711 {
3712     const char *p;
3713     char *q, buf1[20], c;
3714     int nd, len, percentd_found;
3715
3716     q = buf;
3717     p = path;
3718     percentd_found = 0;
3719     for(;;) {
3720         c = *p++;
3721         if (c == '\0')
3722             break;
3723         if (c == '%') {
3724             do {
3725                 nd = 0;
3726                 while (av_isdigit(*p)) {
3727                     nd = nd * 10 + *p++ - '0';
3728                 }
3729                 c = *p++;
3730             } while (av_isdigit(c));
3731
3732             switch(c) {
3733             case '%':
3734                 goto addchar;
3735             case 'd':
3736                 if (percentd_found)
3737                     goto fail;
3738                 percentd_found = 1;
3739                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3740                 len = strlen(buf1);
3741                 if ((q - buf + len) > buf_size - 1)
3742                     goto fail;
3743                 memcpy(q, buf1, len);
3744                 q += len;
3745                 break;
3746             default:
3747                 goto fail;
3748             }
3749         } else {
3750         addchar:
3751             if ((q - buf) < buf_size - 1)
3752                 *q++ = c;
3753         }
3754     }
3755     if (!percentd_found)
3756         goto fail;
3757     *q = '\0';
3758     return 0;
3759  fail:
3760     *q = '\0';
3761     return -1;
3762 }
3763
3764 static void hex_dump_internal(void *avcl, FILE *f, int level,
3765                               const uint8_t *buf, int size)
3766 {
3767     int len, i, j, c;
3768 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3769
3770     for(i=0;i<size;i+=16) {
3771         len = size - i;
3772         if (len > 16)
3773             len = 16;
3774         PRINT("%08x ", i);
3775         for(j=0;j<16;j++) {
3776             if (j < len)
3777                 PRINT(" %02x", buf[i+j]);
3778             else
3779                 PRINT("   ");
3780         }
3781         PRINT(" ");
3782         for(j=0;j<len;j++) {
3783             c = buf[i+j];
3784             if (c < ' ' || c > '~')
3785                 c = '.';
3786             PRINT("%c", c);
3787         }
3788         PRINT("\n");
3789     }
3790 #undef PRINT
3791 }
3792
3793 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3794 {
3795     hex_dump_internal(NULL, f, 0, buf, size);
3796 }
3797
3798 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3799 {
3800     hex_dump_internal(avcl, NULL, level, buf, size);
3801 }
3802
3803 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3804 {
3805 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3806     PRINT("stream #%d:\n", pkt->stream_index);
3807     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3808     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3809     /* DTS is _always_ valid after av_read_frame() */
3810     PRINT("  dts=");
3811     if (pkt->dts == AV_NOPTS_VALUE)
3812         PRINT("N/A");
3813     else
3814         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3815     /* PTS may not be known if B-frames are present. */
3816     PRINT("  pts=");
3817     if (pkt->pts == AV_NOPTS_VALUE)
3818         PRINT("N/A");
3819     else
3820         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3821     PRINT("\n");
3822     PRINT("  size=%d\n", pkt->size);
3823 #undef PRINT
3824     if (dump_payload)
3825         av_hex_dump(f, pkt->data, pkt->size);
3826 }
3827
3828 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3829 {
3830     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3831 }
3832
3833 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3834                       AVStream *st)
3835 {
3836     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3837 }
3838
3839 void av_url_split(char *proto, int proto_size,
3840                   char *authorization, int authorization_size,
3841                   char *hostname, int hostname_size,
3842                   int *port_ptr,
3843                   char *path, int path_size,
3844                   const char *url)
3845 {
3846     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3847
3848     if (port_ptr)               *port_ptr = -1;
3849     if (proto_size > 0)         proto[0] = 0;
3850     if (authorization_size > 0) authorization[0] = 0;
3851     if (hostname_size > 0)      hostname[0] = 0;
3852     if (path_size > 0)          path[0] = 0;
3853
3854     /* parse protocol */
3855     if ((p = strchr(url, ':'))) {
3856         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3857         p++; /* skip ':' */
3858         if (*p == '/') p++;
3859         if (*p == '/') p++;
3860     } else {
3861         /* no protocol means plain filename */
3862         av_strlcpy(path, url, path_size);
3863         return;
3864     }
3865
3866     /* separate path from hostname */
3867     ls = strchr(p, '/');
3868     ls2 = strchr(p, '?');
3869     if(!ls)
3870         ls = ls2;
3871     else if (ls && ls2)
3872         ls = FFMIN(ls, ls2);
3873     if(ls)
3874         av_strlcpy(path, ls, path_size);
3875     else
3876         ls = &p[strlen(p)]; // XXX
3877
3878     /* the rest is hostname, use that to parse auth/port */
3879     if (ls != p) {
3880         /* authorization (user[:pass]@hostname) */
3881         at2 = p;
3882         while ((at = strchr(p, '@')) && at < ls) {
3883             av_strlcpy(authorization, at2,
3884                        FFMIN(authorization_size, at + 1 - at2));
3885             p = at + 1; /* skip '@' */
3886         }
3887
3888         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3889             /* [host]:port */
3890             av_strlcpy(hostname, p + 1,
3891                        FFMIN(hostname_size, brk - p));
3892             if (brk[1] == ':' && port_ptr)
3893                 *port_ptr = atoi(brk + 2);
3894         } else if ((col = strchr(p, ':')) && col < ls) {
3895             av_strlcpy(hostname, p,
3896                        FFMIN(col + 1 - p, hostname_size));
3897             if (port_ptr) *port_ptr = atoi(col + 1);
3898         } else
3899             av_strlcpy(hostname, p,
3900                        FFMIN(ls + 1 - p, hostname_size));
3901     }
3902 }
3903
3904 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3905 {
3906     int i;
3907     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3908                                            '4', '5', '6', '7',
3909                                            '8', '9', 'A', 'B',
3910                                            'C', 'D', 'E', 'F' };
3911     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3912                                            '4', '5', '6', '7',
3913                                            '8', '9', 'a', 'b',
3914                                            'c', 'd', 'e', 'f' };
3915     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3916
3917     for(i = 0; i < s; i++) {
3918         buff[i * 2]     = hex_table[src[i] >> 4];
3919         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3920     }
3921
3922     return buff;
3923 }
3924
3925 int ff_hex_to_data(uint8_t *data, const char *p)
3926 {
3927     int c, len, v;
3928
3929     len = 0;
3930     v = 1;
3931     for (;;) {
3932         p += strspn(p, SPACE_CHARS);
3933         if (*p == '\0')
3934             break;
3935         c = av_toupper((unsigned char) *p++);
3936         if (c >= '0' && c <= '9')
3937             c = c - '0';
3938         else if (c >= 'A' && c <= 'F')
3939             c = c - 'A' + 10;
3940         else
3941             break;
3942         v = (v << 4) | c;
3943         if (v & 0x100) {
3944             if (data)
3945                 data[len] = v;
3946             len++;
3947             v = 1;
3948         }
3949     }
3950     return len;
3951 }
3952
3953 #if FF_API_SET_PTS_INFO
3954 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3955                      unsigned int pts_num, unsigned int pts_den)
3956 {
3957     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3958 }
3959 #endif
3960
3961 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3962                          unsigned int pts_num, unsigned int pts_den)
3963 {
3964     AVRational new_tb;
3965     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3966         if(new_tb.num != pts_num)
3967             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3968     }else
3969         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3970
3971     if(new_tb.num <= 0 || new_tb.den <= 0) {
3972         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);
3973         return;
3974     }
3975     s->time_base = new_tb;
3976     av_codec_set_pkt_timebase(s->codec, new_tb);
3977     s->pts_wrap_bits = pts_wrap_bits;
3978 }
3979
3980 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3981                         void *context)
3982 {
3983     const char *ptr = str;
3984
3985     /* Parse key=value pairs. */
3986     for (;;) {
3987         const char *key;
3988         char *dest = NULL, *dest_end;
3989         int key_len, dest_len = 0;
3990
3991         /* Skip whitespace and potential commas. */
3992         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3993             ptr++;
3994         if (!*ptr)
3995             break;
3996
3997         key = ptr;
3998
3999         if (!(ptr = strchr(key, '=')))
4000             break;
4001         ptr++;
4002         key_len = ptr - key;
4003
4004         callback_get_buf(context, key, key_len, &dest, &dest_len);
4005         dest_end = dest + dest_len - 1;
4006
4007         if (*ptr == '\"') {
4008             ptr++;
4009             while (*ptr && *ptr != '\"') {
4010                 if (*ptr == '\\') {
4011                     if (!ptr[1])
4012                         break;
4013                     if (dest && dest < dest_end)
4014                         *dest++ = ptr[1];
4015                     ptr += 2;
4016                 } else {
4017                     if (dest && dest < dest_end)
4018                         *dest++ = *ptr;
4019                     ptr++;
4020                 }
4021             }
4022             if (*ptr == '\"')
4023                 ptr++;
4024         } else {
4025             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4026                 if (dest && dest < dest_end)
4027                     *dest++ = *ptr;
4028         }
4029         if (dest)
4030             *dest = 0;
4031     }
4032 }
4033
4034 int ff_find_stream_index(AVFormatContext *s, int id)
4035 {
4036     int i;
4037     for (i = 0; i < s->nb_streams; i++) {
4038         if (s->streams[i]->id == id)
4039             return i;
4040     }
4041     return -1;
4042 }
4043
4044 int64_t ff_iso8601_to_unix_time(const char *datestr)
4045 {
4046     struct tm time1 = {0}, time2 = {0};
4047     char *ret1, *ret2;
4048     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4049     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4050     if (ret2 && !ret1)
4051         return av_timegm(&time2);
4052     else
4053         return av_timegm(&time1);
4054 }
4055
4056 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4057 {
4058     if (ofmt) {
4059         if (ofmt->query_codec)
4060             return ofmt->query_codec(codec_id, std_compliance);
4061         else if (ofmt->codec_tag)
4062             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4063         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4064                  codec_id == ofmt->subtitle_codec)
4065             return 1;
4066     }
4067     return AVERROR_PATCHWELCOME;
4068 }
4069
4070 int avformat_network_init(void)
4071 {
4072 #if CONFIG_NETWORK
4073     int ret;
4074     ff_network_inited_globally = 1;
4075     if ((ret = ff_network_init()) < 0)
4076         return ret;
4077     ff_tls_init();
4078 #endif
4079     return 0;
4080 }
4081
4082 int avformat_network_deinit(void)
4083 {
4084 #if CONFIG_NETWORK
4085     ff_network_close();
4086     ff_tls_deinit();
4087 #endif
4088     return 0;
4089 }
4090
4091 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4092                         uint64_t channel_layout, int32_t sample_rate,
4093                         int32_t width, int32_t height)
4094 {
4095     uint32_t flags = 0;
4096     int size = 4;
4097     uint8_t *data;
4098     if (!pkt)
4099         return AVERROR(EINVAL);
4100     if (channels) {
4101         size += 4;
4102         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4103     }
4104     if (channel_layout) {
4105         size += 8;
4106         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4107     }
4108     if (sample_rate) {
4109         size += 4;
4110         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4111     }
4112     if (width || height) {
4113         size += 8;
4114         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4115     }
4116     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4117     if (!data)
4118         return AVERROR(ENOMEM);
4119     bytestream_put_le32(&data, flags);
4120     if (channels)
4121         bytestream_put_le32(&data, channels);
4122     if (channel_layout)
4123         bytestream_put_le64(&data, channel_layout);
4124     if (sample_rate)
4125         bytestream_put_le32(&data, sample_rate);
4126     if (width || height) {
4127         bytestream_put_le32(&data, width);
4128         bytestream_put_le32(&data, height);
4129     }
4130     return 0;
4131 }
4132
4133 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4134 {
4135     AVRational undef = {0, 1};
4136     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4137     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4138     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4139
4140     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4141                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4142     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4143         stream_sample_aspect_ratio = undef;
4144
4145     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4146                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4147     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4148         frame_sample_aspect_ratio = undef;
4149
4150     if (stream_sample_aspect_ratio.num)
4151         return stream_sample_aspect_ratio;
4152     else
4153         return frame_sample_aspect_ratio;
4154 }
4155
4156 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4157 {
4158     AVRational fr = st->r_frame_rate;
4159
4160     if (st->codec->ticks_per_frame > 1) {
4161         AVRational codec_fr = av_inv_q(st->codec->time_base);
4162         AVRational   avg_fr = st->avg_frame_rate;
4163         codec_fr.den *= st->codec->ticks_per_frame;
4164         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4165             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4166             fr = codec_fr;
4167     }
4168
4169     return fr;
4170 }
4171
4172 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4173                                     const char *spec)
4174 {
4175     if (*spec <= '9' && *spec >= '0') /* opt:index */
4176         return strtol(spec, NULL, 0) == st->index;
4177     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4178              *spec == 't') { /* opt:[vasdt] */
4179         enum AVMediaType type;
4180
4181         switch (*spec++) {
4182         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4183         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4184         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4185         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4186         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4187         default:  av_assert0(0);
4188         }
4189         if (type != st->codec->codec_type)
4190             return 0;
4191         if (*spec++ == ':') { /* possibly followed by :index */
4192             int i, index = strtol(spec, NULL, 0);
4193             for (i = 0; i < s->nb_streams; i++)
4194                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4195                    return i == st->index;
4196             return 0;
4197         }
4198         return 1;
4199     } else if (*spec == 'p' && *(spec + 1) == ':') {
4200         int prog_id, i, j;
4201         char *endptr;
4202         spec += 2;
4203         prog_id = strtol(spec, &endptr, 0);
4204         for (i = 0; i < s->nb_programs; i++) {
4205             if (s->programs[i]->id != prog_id)
4206                 continue;
4207
4208             if (*endptr++ == ':') {
4209                 int stream_idx = strtol(endptr, NULL, 0);
4210                 return stream_idx >= 0 &&
4211                     stream_idx < s->programs[i]->nb_stream_indexes &&
4212                     st->index == s->programs[i]->stream_index[stream_idx];
4213             }
4214
4215             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4216                 if (st->index == s->programs[i]->stream_index[j])
4217                     return 1;
4218         }
4219         return 0;
4220     } else if (*spec == '#') {
4221         int sid;
4222         char *endptr;
4223         sid = strtol(spec + 1, &endptr, 0);
4224         if (!*endptr)
4225             return st->id == sid;
4226     } else if (!*spec) /* empty specifier, matches everything */
4227         return 1;
4228
4229     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4230     return AVERROR(EINVAL);
4231 }
4232
4233 int ff_generate_avci_extradata(AVStream *st)
4234 {
4235     static const uint8_t avci100_1080p_extradata[] = {
4236         // SPS
4237         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4238         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4239         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4240         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4241         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4242         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4243         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4244         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4245         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4246         // PPS
4247         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4248         0xd0
4249     };
4250     static const uint8_t avci100_1080i_extradata[] = {
4251         // SPS
4252         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4253         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4254         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4255         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4256         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4257         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4258         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4259         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4260         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4261         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4262         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4263         // PPS
4264         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4265         0xd0
4266     };
4267     static const uint8_t avci50_1080i_extradata[] = {
4268         // SPS
4269         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4270         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4271         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4272         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4273         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4274         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4275         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4276         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4277         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4278         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4279         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4280         // PPS
4281         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4282         0x11
4283     };
4284     static const uint8_t avci100_720p_extradata[] = {
4285         // SPS
4286         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4287         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4288         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4289         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4290         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4291         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4292         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4293         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4294         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4295         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4296         // PPS
4297         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4298         0x11
4299     };
4300
4301     const uint8_t *data = NULL;
4302     int size = 0;
4303
4304     if (st->codec->width == 1920) {
4305         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4306             data = avci100_1080p_extradata;
4307             size = sizeof(avci100_1080p_extradata);
4308         } else {
4309             data = avci100_1080i_extradata;
4310             size = sizeof(avci100_1080i_extradata);
4311         }
4312     } else if (st->codec->width == 1440) {
4313         data = avci50_1080i_extradata;
4314         size = sizeof(avci50_1080i_extradata);
4315     } else if (st->codec->width == 1280) {
4316         data = avci100_720p_extradata;
4317         size = sizeof(avci100_720p_extradata);
4318     }
4319
4320     if (!size)
4321         return 0;
4322
4323     av_freep(&st->codec->extradata);
4324     if (ff_alloc_extradata(st->codec, size))
4325         return AVERROR(ENOMEM);
4326     memcpy(st->codec->extradata, data, size);
4327
4328     return 0;
4329 }