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     av_frame_free(&frame);
2537     return ret;
2538 }
2539
2540 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2541 {
2542     while (tags->id != AV_CODEC_ID_NONE) {
2543         if (tags->id == id)
2544             return tags->tag;
2545         tags++;
2546     }
2547     return 0;
2548 }
2549
2550 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2551 {
2552     int i;
2553     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2554         if(tag == tags[i].tag)
2555             return tags[i].id;
2556     }
2557     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2558         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2559             return tags[i].id;
2560     }
2561     return AV_CODEC_ID_NONE;
2562 }
2563
2564 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2565 {
2566     if (flt) {
2567         switch (bps) {
2568         case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2569         case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2570         default: return AV_CODEC_ID_NONE;
2571         }
2572     } else {
2573         bps  += 7;
2574         bps >>= 3;
2575         if (sflags & (1 << (bps - 1))) {
2576             switch (bps) {
2577             case 1:  return AV_CODEC_ID_PCM_S8;
2578             case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2579             case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2580             case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2581             default: return AV_CODEC_ID_NONE;
2582             }
2583         } else {
2584             switch (bps) {
2585             case 1:  return AV_CODEC_ID_PCM_U8;
2586             case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2587             case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2588             case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2589             default: return AV_CODEC_ID_NONE;
2590             }
2591         }
2592     }
2593 }
2594
2595 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2596 {
2597     unsigned int tag;
2598     if (!av_codec_get_tag2(tags, id, &tag))
2599         return 0;
2600     return tag;
2601 }
2602
2603 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2604                       unsigned int *tag)
2605 {
2606     int i;
2607     for(i=0; tags && tags[i]; i++){
2608         const AVCodecTag *codec_tags = tags[i];
2609         while (codec_tags->id != AV_CODEC_ID_NONE) {
2610             if (codec_tags->id == id) {
2611                 *tag = codec_tags->tag;
2612                 return 1;
2613             }
2614             codec_tags++;
2615         }
2616     }
2617     return 0;
2618 }
2619
2620 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2621 {
2622     int i;
2623     for(i=0; tags && tags[i]; i++){
2624         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2625         if(id!=AV_CODEC_ID_NONE) return id;
2626     }
2627     return AV_CODEC_ID_NONE;
2628 }
2629
2630 static void compute_chapters_end(AVFormatContext *s)
2631 {
2632     unsigned int i, j;
2633     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2634
2635     for (i = 0; i < s->nb_chapters; i++)
2636         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2637             AVChapter *ch = s->chapters[i];
2638             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2639                                      : INT64_MAX;
2640
2641             for (j = 0; j < s->nb_chapters; j++) {
2642                 AVChapter *ch1 = s->chapters[j];
2643                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2644                 if (j != i && next_start > ch->start && next_start < end)
2645                     end = next_start;
2646             }
2647             ch->end = (end == INT64_MAX) ? ch->start : end;
2648         }
2649 }
2650
2651 static int get_std_framerate(int i){
2652     if(i<60*12) return (i+1)*1001;
2653     else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2654 }
2655
2656 /*
2657  * Is the time base unreliable.
2658  * This is a heuristic to balance between quick acceptance of the values in
2659  * the headers vs. some extra checks.
2660  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2661  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2662  * And there are "variable" fps files this needs to detect as well.
2663  */
2664 static int tb_unreliable(AVCodecContext *c){
2665     if(   c->time_base.den >= 101L*c->time_base.num
2666        || c->time_base.den <    5L*c->time_base.num
2667 /*       || c->codec_tag == AV_RL32("DIVX")
2668        || c->codec_tag == AV_RL32("XVID")*/
2669        || c->codec_tag == AV_RL32("mp4v")
2670        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2671        || c->codec_id == AV_CODEC_ID_H264
2672        )
2673         return 1;
2674     return 0;
2675 }
2676
2677 #if FF_API_FORMAT_PARAMETERS
2678 int av_find_stream_info(AVFormatContext *ic)
2679 {
2680     return avformat_find_stream_info(ic, NULL);
2681 }
2682 #endif
2683
2684 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2685 {
2686     int ret;
2687
2688     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2689         avctx->extradata_size = 0;
2690         return AVERROR(EINVAL);
2691     }
2692     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2693     if (avctx->extradata) {
2694         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2695         avctx->extradata_size = size;
2696         ret = 0;
2697     } else {
2698         avctx->extradata_size = 0;
2699         ret = AVERROR(ENOMEM);
2700     }
2701     return ret;
2702 }
2703
2704 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2705 {
2706     int i, j;
2707     int64_t last = st->info->last_dts;
2708
2709     if(   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2710        && ts - (uint64_t)last < INT64_MAX){
2711         double dts= (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2712         int64_t duration= ts - last;
2713
2714         if (!st->info->duration_error)
2715             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2716         if (!st->info->duration_error)
2717             return AVERROR(ENOMEM);
2718
2719 //         if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2720 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2721         for (i=0; i<MAX_STD_TIMEBASES; i++) {
2722             if (st->info->duration_error[0][1][i] < 1e10) {
2723                 int framerate= get_std_framerate(i);
2724                 double sdts= dts*framerate/(1001*12);
2725                 for(j=0; j<2; j++){
2726                     int64_t ticks= llrint(sdts+j*0.5);
2727                     double error= sdts - ticks + j*0.5;
2728                     st->info->duration_error[j][0][i] += error;
2729                     st->info->duration_error[j][1][i] += error*error;
2730                 }
2731             }
2732         }
2733         st->info->duration_count++;
2734
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             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2862                 av_log(ic, AV_LOG_WARNING, "Failed to open codec in av_find_stream_info\n");
2863         }
2864
2865         //try to just open decoders, in case this is enough to get parameters
2866         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2867             if (codec && !st->codec->codec)
2868                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
2869                     av_log(ic, AV_LOG_WARNING, "Failed to open codec in av_find_stream_info\n");
2870         }
2871         if (!options)
2872             av_dict_free(&thread_opt);
2873     }
2874
2875     for (i=0; i<ic->nb_streams; i++) {
2876 #if FF_API_R_FRAME_RATE
2877         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2878 #endif
2879         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2880         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2881     }
2882
2883     count = 0;
2884     read_size = 0;
2885     for(;;) {
2886         if (ff_check_interrupt(&ic->interrupt_callback)){
2887             ret= AVERROR_EXIT;
2888             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2889             break;
2890         }
2891
2892         /* check if one codec still needs to be handled */
2893         for(i=0;i<ic->nb_streams;i++) {
2894             int fps_analyze_framecount = 20;
2895
2896             st = ic->streams[i];
2897             if (!has_codec_parameters(st, NULL))
2898                 break;
2899             /* if the timebase is coarse (like the usual millisecond precision
2900                of mkv), we need to analyze more frames to reliably arrive at
2901                the correct fps */
2902             if (av_q2d(st->time_base) > 0.0005)
2903                 fps_analyze_framecount *= 2;
2904             if (ic->fps_probe_size >= 0)
2905                 fps_analyze_framecount = ic->fps_probe_size;
2906             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2907                 fps_analyze_framecount = 0;
2908             /* variable fps and no guess at the real fps */
2909             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2910                && st->info->duration_count < fps_analyze_framecount
2911                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2912                 break;
2913             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2914                 break;
2915             if (st->first_dts == AV_NOPTS_VALUE &&
2916                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2917                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2918                 break;
2919         }
2920         if (i == ic->nb_streams) {
2921             /* NOTE: if the format has no header, then we need to read
2922                some packets to get most of the streams, so we cannot
2923                stop here */
2924             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2925                 /* if we found the info for all the codecs, we can stop */
2926                 ret = count;
2927                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2928                 flush_codecs = 0;
2929                 break;
2930             }
2931         }
2932         /* we did not get all the codec info, but we read too much data */
2933         if (read_size >= ic->probesize) {
2934             ret = count;
2935             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2936             for (i = 0; i < ic->nb_streams; i++)
2937                 if (!ic->streams[i]->r_frame_rate.num &&
2938                     ic->streams[i]->info->duration_count <= 1 &&
2939                     strcmp(ic->iformat->name, "image2"))
2940                     av_log(ic, AV_LOG_WARNING,
2941                            "Stream #%d: not enough frames to estimate rate; "
2942                            "consider increasing probesize\n", i);
2943             break;
2944         }
2945
2946         /* NOTE: a new stream can be added there if no header in file
2947            (AVFMTCTX_NOHEADER) */
2948         ret = read_frame_internal(ic, &pkt1);
2949         if (ret == AVERROR(EAGAIN))
2950             continue;
2951
2952         if (ret < 0) {
2953             /* EOF or error*/
2954             break;
2955         }
2956
2957         if (ic->flags & AVFMT_FLAG_NOBUFFER)
2958             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2959         {
2960             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2961                                 &ic->packet_buffer_end);
2962             if (!pkt) {
2963                 ret = AVERROR(ENOMEM);
2964                 goto find_stream_info_err;
2965             }
2966             if ((ret = av_dup_packet(pkt)) < 0)
2967                 goto find_stream_info_err;
2968         }
2969
2970         st = ic->streams[pkt->stream_index];
2971         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2972             read_size += pkt->size;
2973
2974         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2975             /* check for non-increasing dts */
2976             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2977                 st->info->fps_last_dts >= pkt->dts) {
2978                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2979                        "packet %d with DTS %"PRId64", packet %d with DTS "
2980                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2981                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2982                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2983             }
2984             /* check for a discontinuity in dts - if the difference in dts
2985              * is more than 1000 times the average packet duration in the sequence,
2986              * we treat it as a discontinuity */
2987             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2988                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2989                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2990                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2991                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2992                        "packet %d with DTS %"PRId64", packet %d with DTS "
2993                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2994                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2995                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2996             }
2997
2998             /* update stored dts values */
2999             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3000                 st->info->fps_first_dts     = pkt->dts;
3001                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3002             }
3003             st->info->fps_last_dts = pkt->dts;
3004             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3005         }
3006         if (st->codec_info_nb_frames>1) {
3007             int64_t t=0;
3008             if (st->time_base.den > 0)
3009                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3010             if (st->avg_frame_rate.num > 0)
3011                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3012
3013             if (   t==0
3014                 && st->codec_info_nb_frames>30
3015                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3016                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3017                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3018
3019             if (t >= ic->max_analyze_duration) {
3020                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
3021                 break;
3022             }
3023             if (pkt->duration) {
3024                 st->info->codec_info_duration        += pkt->duration;
3025                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
3026             }
3027         }
3028 #if FF_API_R_FRAME_RATE
3029         ff_rfps_add_frame(ic, st, pkt->dts);
3030 #endif
3031         if(st->parser && st->parser->parser->split && !st->codec->extradata){
3032             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
3033             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3034                 if (ff_alloc_extradata(st->codec, i))
3035                     return AVERROR(ENOMEM);
3036                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
3037             }
3038         }
3039
3040         /* if still no information, we try to open the codec and to
3041            decompress the frame. We try to avoid that in most cases as
3042            it takes longer and uses more memory. For MPEG-4, we need to
3043            decompress for QuickTime.
3044
3045            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3046            least one frame of codec data, this makes sure the codec initializes
3047            the channel configuration and does not only trust the values from the container.
3048         */
3049         try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
3050
3051         st->codec_info_nb_frames++;
3052         count++;
3053     }
3054
3055     if (flush_codecs) {
3056         AVPacket empty_pkt = { 0 };
3057         int err = 0;
3058         av_init_packet(&empty_pkt);
3059
3060         for(i=0;i<ic->nb_streams;i++) {
3061
3062             st = ic->streams[i];
3063
3064             /* flush the decoders */
3065             if (st->info->found_decoder == 1) {
3066                 do {
3067                     err = try_decode_frame(ic, st, &empty_pkt,
3068                                             (options && i < orig_nb_streams) ?
3069                                             &options[i] : NULL);
3070                 } while (err > 0 && !has_codec_parameters(st, NULL));
3071
3072                 if (err < 0) {
3073                     av_log(ic, AV_LOG_INFO,
3074                         "decoding for stream %d failed\n", st->index);
3075                 }
3076             }
3077         }
3078     }
3079
3080     // close codecs which were opened in try_decode_frame()
3081     for(i=0;i<ic->nb_streams;i++) {
3082         st = ic->streams[i];
3083         avcodec_close(st->codec);
3084     }
3085
3086     ff_rfps_calculate(ic);
3087
3088     for(i=0;i<ic->nb_streams;i++) {
3089         st = ic->streams[i];
3090         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3091             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3092                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3093                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3094                     st->codec->codec_tag= tag;
3095             }
3096
3097             /* estimate average framerate if not set by demuxer */
3098             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3099                 int      best_fps = 0;
3100                 double best_error = 0.01;
3101
3102                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3103                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3104                     st->info->codec_info_duration        < 0)
3105                     continue;
3106                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3107                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3108                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3109
3110                 /* round guessed framerate to a "standard" framerate if it's
3111                  * within 1% of the original estimate*/
3112                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3113                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
3114                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3115
3116                     if (error < best_error) {
3117                         best_error = error;
3118                         best_fps   = std_fps.num;
3119                     }
3120                 }
3121                 if (best_fps) {
3122                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3123                               best_fps, 12*1001, INT_MAX);
3124                 }
3125             }
3126
3127             if (!st->r_frame_rate.num){
3128                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3129                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3130                     st->r_frame_rate.num = st->codec->time_base.den;
3131                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3132                 }else{
3133                     st->r_frame_rate.num = st->time_base.den;
3134                     st->r_frame_rate.den = st->time_base.num;
3135                 }
3136             }
3137         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3138             if(!st->codec->bits_per_coded_sample)
3139                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3140             // set stream disposition based on audio service type
3141             switch (st->codec->audio_service_type) {
3142             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3143                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3144             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3145                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3146             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3147                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3148             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3149                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3150             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3151                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3152             }
3153         }
3154     }
3155
3156     if(ic->probesize)
3157     estimate_timings(ic, old_offset);
3158
3159     if (ret >= 0 && ic->nb_streams)
3160         ret = -1; /* we could not have all the codec parameters before EOF */
3161     for(i=0;i<ic->nb_streams;i++) {
3162         const char *errmsg;
3163         st = ic->streams[i];
3164         if (!has_codec_parameters(st, &errmsg)) {
3165             char buf[256];
3166             avcodec_string(buf, sizeof(buf), st->codec, 0);
3167             av_log(ic, AV_LOG_WARNING,
3168                    "Could not find codec parameters for stream %d (%s): %s\n"
3169                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3170                    i, buf, errmsg);
3171         } else {
3172             ret = 0;
3173         }
3174     }
3175
3176     compute_chapters_end(ic);
3177
3178  find_stream_info_err:
3179     for (i=0; i < ic->nb_streams; i++) {
3180         st = ic->streams[i];
3181         if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3182             ic->streams[i]->codec->thread_count = 0;
3183         if (st->info)
3184             av_freep(&st->info->duration_error);
3185         av_freep(&ic->streams[i]->info);
3186     }
3187     if(ic->pb)
3188         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3189                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3190     return ret;
3191 }
3192
3193 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3194 {
3195     int i, j;
3196
3197     for (i = 0; i < ic->nb_programs; i++) {
3198         if (ic->programs[i] == last) {
3199             last = NULL;
3200         } else {
3201             if (!last)
3202                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3203                     if (ic->programs[i]->stream_index[j] == s)
3204                         return ic->programs[i];
3205         }
3206     }
3207     return NULL;
3208 }
3209
3210 int av_find_best_stream(AVFormatContext *ic,
3211                         enum AVMediaType type,
3212                         int wanted_stream_nb,
3213                         int related_stream,
3214                         AVCodec **decoder_ret,
3215                         int flags)
3216 {
3217     int i, nb_streams = ic->nb_streams;
3218     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3219     unsigned *program = NULL;
3220     AVCodec *decoder = NULL, *best_decoder = NULL;
3221
3222     if (related_stream >= 0 && wanted_stream_nb < 0) {
3223         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3224         if (p) {
3225             program = p->stream_index;
3226             nb_streams = p->nb_stream_indexes;
3227         }
3228     }
3229     for (i = 0; i < nb_streams; i++) {
3230         int real_stream_index = program ? program[i] : i;
3231         AVStream *st = ic->streams[real_stream_index];
3232         AVCodecContext *avctx = st->codec;
3233         if (avctx->codec_type != type)
3234             continue;
3235         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3236             continue;
3237         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3238             continue;
3239         if (decoder_ret) {
3240             decoder = find_decoder(ic, st, st->codec->codec_id);
3241             if (!decoder) {
3242                 if (ret < 0)
3243                     ret = AVERROR_DECODER_NOT_FOUND;
3244                 continue;
3245             }
3246         }
3247         count = st->codec_info_nb_frames;
3248         bitrate = avctx->bit_rate;
3249         multiframe = FFMIN(5, count);
3250         if ((best_multiframe >  multiframe) ||
3251             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3252             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3253             continue;
3254         best_count = count;
3255         best_bitrate = bitrate;
3256         best_multiframe = multiframe;
3257         ret = real_stream_index;
3258         best_decoder = decoder;
3259         if (program && i == nb_streams - 1 && ret < 0) {
3260             program = NULL;
3261             nb_streams = ic->nb_streams;
3262             i = 0; /* no related stream found, try again with everything */
3263         }
3264     }
3265     if (decoder_ret)
3266         *decoder_ret = best_decoder;
3267     return ret;
3268 }
3269
3270 /*******************************************************/
3271
3272 int av_read_play(AVFormatContext *s)
3273 {
3274     if (s->iformat->read_play)
3275         return s->iformat->read_play(s);
3276     if (s->pb)
3277         return avio_pause(s->pb, 0);
3278     return AVERROR(ENOSYS);
3279 }
3280
3281 int av_read_pause(AVFormatContext *s)
3282 {
3283     if (s->iformat->read_pause)
3284         return s->iformat->read_pause(s);
3285     if (s->pb)
3286         return avio_pause(s->pb, 1);
3287     return AVERROR(ENOSYS);
3288 }
3289
3290 void ff_free_stream(AVFormatContext *s, AVStream *st){
3291     av_assert0(s->nb_streams>0);
3292     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3293
3294     if (st->parser) {
3295         av_parser_close(st->parser);
3296     }
3297     if (st->attached_pic.data)
3298         av_free_packet(&st->attached_pic);
3299     av_dict_free(&st->metadata);
3300     av_freep(&st->probe_data.buf);
3301     av_freep(&st->index_entries);
3302     av_freep(&st->codec->extradata);
3303     av_freep(&st->codec->subtitle_header);
3304     av_freep(&st->codec);
3305     av_freep(&st->priv_data);
3306     if (st->info)
3307         av_freep(&st->info->duration_error);
3308     av_freep(&st->info);
3309     av_freep(&s->streams[ --s->nb_streams ]);
3310 }
3311
3312 void avformat_free_context(AVFormatContext *s)
3313 {
3314     int i;
3315
3316     if (!s)
3317         return;
3318
3319     av_opt_free(s);
3320     if (s->iformat && s->iformat->priv_class && s->priv_data)
3321         av_opt_free(s->priv_data);
3322
3323     for(i=s->nb_streams-1; i>=0; i--) {
3324         ff_free_stream(s, s->streams[i]);
3325     }
3326     for(i=s->nb_programs-1; i>=0; i--) {
3327         av_dict_free(&s->programs[i]->metadata);
3328         av_freep(&s->programs[i]->stream_index);
3329         av_freep(&s->programs[i]);
3330     }
3331     av_freep(&s->programs);
3332     av_freep(&s->priv_data);
3333     while(s->nb_chapters--) {
3334         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3335         av_freep(&s->chapters[s->nb_chapters]);
3336     }
3337     av_freep(&s->chapters);
3338     av_dict_free(&s->metadata);
3339     av_freep(&s->streams);
3340     av_free(s);
3341 }
3342
3343 #if FF_API_CLOSE_INPUT_FILE
3344 void av_close_input_file(AVFormatContext *s)
3345 {
3346     avformat_close_input(&s);
3347 }
3348 #endif
3349
3350 void avformat_close_input(AVFormatContext **ps)
3351 {
3352     AVFormatContext *s;
3353     AVIOContext *pb;
3354
3355     if (!ps || !*ps)
3356         return;
3357
3358     s = *ps;
3359     pb = s->pb;
3360
3361     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3362         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3363         pb = NULL;
3364
3365     flush_packet_queue(s);
3366
3367     if (s->iformat) {
3368         if (s->iformat->read_close)
3369             s->iformat->read_close(s);
3370     }
3371
3372     avformat_free_context(s);
3373
3374     *ps = NULL;
3375
3376     avio_close(pb);
3377 }
3378
3379 #if FF_API_NEW_STREAM
3380 AVStream *av_new_stream(AVFormatContext *s, int id)
3381 {
3382     AVStream *st = avformat_new_stream(s, NULL);
3383     if (st)
3384         st->id = id;
3385     return st;
3386 }
3387 #endif
3388
3389 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3390 {
3391     AVStream *st;
3392     int i;
3393     AVStream **streams;
3394
3395     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3396         return NULL;
3397     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3398     if (!streams)
3399         return NULL;
3400     s->streams = streams;
3401
3402     st = av_mallocz(sizeof(AVStream));
3403     if (!st)
3404         return NULL;
3405     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3406         av_free(st);
3407         return NULL;
3408     }
3409     st->info->last_dts = AV_NOPTS_VALUE;
3410
3411     st->codec = avcodec_alloc_context3(c);
3412     if (s->iformat) {
3413         /* no default bitrate if decoding */
3414         st->codec->bit_rate = 0;
3415     }
3416     st->index = s->nb_streams;
3417     st->start_time = AV_NOPTS_VALUE;
3418     st->duration = AV_NOPTS_VALUE;
3419         /* we set the current DTS to 0 so that formats without any timestamps
3420            but durations get some timestamps, formats with some unknown
3421            timestamps have their first few packets buffered and the
3422            timestamps corrected before they are returned to the user */
3423     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3424     st->first_dts = AV_NOPTS_VALUE;
3425     st->probe_packets = MAX_PROBE_PACKETS;
3426     st->pts_wrap_reference = AV_NOPTS_VALUE;
3427     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3428
3429     /* default pts setting is MPEG-like */
3430     avpriv_set_pts_info(st, 33, 1, 90000);
3431     st->last_IP_pts = AV_NOPTS_VALUE;
3432     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3433         st->pts_buffer[i]= AV_NOPTS_VALUE;
3434
3435     st->sample_aspect_ratio = (AVRational){0,1};
3436
3437 #if FF_API_R_FRAME_RATE
3438     st->info->last_dts      = AV_NOPTS_VALUE;
3439 #endif
3440     st->info->fps_first_dts = AV_NOPTS_VALUE;
3441     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3442
3443     s->streams[s->nb_streams++] = st;
3444     return st;
3445 }
3446
3447 AVProgram *av_new_program(AVFormatContext *ac, int id)
3448 {
3449     AVProgram *program=NULL;
3450     int i;
3451
3452     av_dlog(ac, "new_program: id=0x%04x\n", id);
3453
3454     for(i=0; i<ac->nb_programs; i++)
3455         if(ac->programs[i]->id == id)
3456             program = ac->programs[i];
3457
3458     if(!program){
3459         program = av_mallocz(sizeof(AVProgram));
3460         if (!program)
3461             return NULL;
3462         dynarray_add(&ac->programs, &ac->nb_programs, program);
3463         program->discard = AVDISCARD_NONE;
3464     }
3465     program->id = id;
3466     program->pts_wrap_reference = AV_NOPTS_VALUE;
3467     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3468
3469     program->start_time =
3470     program->end_time   = AV_NOPTS_VALUE;
3471
3472     return program;
3473 }
3474
3475 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3476 {
3477     AVChapter *chapter = NULL;
3478     int i;
3479
3480     for(i=0; i<s->nb_chapters; i++)
3481         if(s->chapters[i]->id == id)
3482             chapter = s->chapters[i];
3483
3484     if(!chapter){
3485         chapter= av_mallocz(sizeof(AVChapter));
3486         if(!chapter)
3487             return NULL;
3488         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3489     }
3490     av_dict_set(&chapter->metadata, "title", title, 0);
3491     chapter->id    = id;
3492     chapter->time_base= time_base;
3493     chapter->start = start;
3494     chapter->end   = end;
3495
3496     return chapter;
3497 }
3498
3499 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3500 {
3501     int i, j;
3502     AVProgram *program=NULL;
3503     void *tmp;
3504
3505     if (idx >= ac->nb_streams) {
3506         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3507         return;
3508     }
3509
3510     for(i=0; i<ac->nb_programs; i++){
3511         if(ac->programs[i]->id != progid)
3512             continue;
3513         program = ac->programs[i];
3514         for(j=0; j<program->nb_stream_indexes; j++)
3515             if(program->stream_index[j] == idx)
3516                 return;
3517
3518         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3519         if(!tmp)
3520             return;
3521         program->stream_index = tmp;
3522         program->stream_index[program->nb_stream_indexes++] = idx;
3523         return;
3524     }
3525 }
3526
3527 static void print_fps(double d, const char *postfix){
3528     uint64_t v= lrintf(d*100);
3529     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3530     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3531     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3532 }
3533
3534 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3535 {
3536     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3537         AVDictionaryEntry *tag=NULL;
3538
3539         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3540         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3541             if(strcmp("language", tag->key)){
3542                 const char *p = tag->value;
3543                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3544                 while(*p) {
3545                     char tmp[256];
3546                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3547                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3548                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3549                     p += len;
3550                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3551                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3552                     if (*p) p++;
3553                 }
3554                 av_log(ctx, AV_LOG_INFO, "\n");
3555             }
3556         }
3557     }
3558 }
3559
3560 /* "user interface" functions */
3561 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3562 {
3563     char buf[256];
3564     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3565     AVStream *st = ic->streams[i];
3566     int g = av_gcd(st->time_base.num, st->time_base.den);
3567     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3568     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3569     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3570     /* the pid is an important information, so we display it */
3571     /* XXX: add a generic system */
3572     if (flags & AVFMT_SHOW_IDS)
3573         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3574     if (lang)
3575         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3576     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3577     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3578     if (st->sample_aspect_ratio.num && // default
3579         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3580         AVRational display_aspect_ratio;
3581         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3582                   st->codec->width*st->sample_aspect_ratio.num,
3583                   st->codec->height*st->sample_aspect_ratio.den,
3584                   1024*1024);
3585         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3586                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3587                  display_aspect_ratio.num, display_aspect_ratio.den);
3588     }
3589     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3590         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3591             print_fps(av_q2d(st->avg_frame_rate), "fps");
3592 #if FF_API_R_FRAME_RATE
3593         if(st->r_frame_rate.den && st->r_frame_rate.num)
3594             print_fps(av_q2d(st->r_frame_rate), "tbr");
3595 #endif
3596         if(st->time_base.den && st->time_base.num)
3597             print_fps(1/av_q2d(st->time_base), "tbn");
3598         if(st->codec->time_base.den && st->codec->time_base.num)
3599             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3600     }
3601     if (st->disposition & AV_DISPOSITION_DEFAULT)
3602         av_log(NULL, AV_LOG_INFO, " (default)");
3603     if (st->disposition & AV_DISPOSITION_DUB)
3604         av_log(NULL, AV_LOG_INFO, " (dub)");
3605     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3606         av_log(NULL, AV_LOG_INFO, " (original)");
3607     if (st->disposition & AV_DISPOSITION_COMMENT)
3608         av_log(NULL, AV_LOG_INFO, " (comment)");
3609     if (st->disposition & AV_DISPOSITION_LYRICS)
3610         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3611     if (st->disposition & AV_DISPOSITION_KARAOKE)
3612         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3613     if (st->disposition & AV_DISPOSITION_FORCED)
3614         av_log(NULL, AV_LOG_INFO, " (forced)");
3615     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3616         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3617     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3618         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3619     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3620         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3621     av_log(NULL, AV_LOG_INFO, "\n");
3622     dump_metadata(NULL, st->metadata, "    ");
3623 }
3624
3625 void av_dump_format(AVFormatContext *ic,
3626                     int index,
3627                     const char *url,
3628                     int is_output)
3629 {
3630     int i;
3631     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3632     if (ic->nb_streams && !printed)
3633         return;
3634
3635     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3636             is_output ? "Output" : "Input",
3637             index,
3638             is_output ? ic->oformat->name : ic->iformat->name,
3639             is_output ? "to" : "from", url);
3640     dump_metadata(NULL, ic->metadata, "  ");
3641     if (!is_output) {
3642         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3643         if (ic->duration != AV_NOPTS_VALUE) {
3644             int hours, mins, secs, us;
3645             int64_t duration = ic->duration + 5000;
3646             secs = duration / AV_TIME_BASE;
3647             us = duration % AV_TIME_BASE;
3648             mins = secs / 60;
3649             secs %= 60;
3650             hours = mins / 60;
3651             mins %= 60;
3652             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3653                    (100 * us) / AV_TIME_BASE);
3654         } else {
3655             av_log(NULL, AV_LOG_INFO, "N/A");
3656         }
3657         if (ic->start_time != AV_NOPTS_VALUE) {
3658             int secs, us;
3659             av_log(NULL, AV_LOG_INFO, ", start: ");
3660             secs = ic->start_time / AV_TIME_BASE;
3661             us = abs(ic->start_time % AV_TIME_BASE);
3662             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3663                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3664         }
3665         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3666         if (ic->bit_rate) {
3667             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3668         } else {
3669             av_log(NULL, AV_LOG_INFO, "N/A");
3670         }
3671         av_log(NULL, AV_LOG_INFO, "\n");
3672     }
3673     for (i = 0; i < ic->nb_chapters; i++) {
3674         AVChapter *ch = ic->chapters[i];
3675         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3676         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3677         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3678
3679         dump_metadata(NULL, ch->metadata, "    ");
3680     }
3681     if(ic->nb_programs) {
3682         int j, k, total = 0;
3683         for(j=0; j<ic->nb_programs; j++) {
3684             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3685                                                   "name", NULL, 0);
3686             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3687                    name ? name->value : "");
3688             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3689             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3690                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3691                 printed[ic->programs[j]->stream_index[k]] = 1;
3692             }
3693             total += ic->programs[j]->nb_stream_indexes;
3694         }
3695         if (total < ic->nb_streams)
3696             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3697     }
3698     for(i=0;i<ic->nb_streams;i++)
3699         if (!printed[i])
3700             dump_stream_format(ic, i, index, is_output);
3701
3702     av_free(printed);
3703 }
3704
3705 uint64_t ff_ntp_time(void)
3706 {
3707   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3708 }
3709
3710 int av_get_frame_filename(char *buf, int buf_size,
3711                           const char *path, int number)
3712 {
3713     const char *p;
3714     char *q, buf1[20], c;
3715     int nd, len, percentd_found;
3716
3717     q = buf;
3718     p = path;
3719     percentd_found = 0;
3720     for(;;) {
3721         c = *p++;
3722         if (c == '\0')
3723             break;
3724         if (c == '%') {
3725             do {
3726                 nd = 0;
3727                 while (av_isdigit(*p)) {
3728                     nd = nd * 10 + *p++ - '0';
3729                 }
3730                 c = *p++;
3731             } while (av_isdigit(c));
3732
3733             switch(c) {
3734             case '%':
3735                 goto addchar;
3736             case 'd':
3737                 if (percentd_found)
3738                     goto fail;
3739                 percentd_found = 1;
3740                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3741                 len = strlen(buf1);
3742                 if ((q - buf + len) > buf_size - 1)
3743                     goto fail;
3744                 memcpy(q, buf1, len);
3745                 q += len;
3746                 break;
3747             default:
3748                 goto fail;
3749             }
3750         } else {
3751         addchar:
3752             if ((q - buf) < buf_size - 1)
3753                 *q++ = c;
3754         }
3755     }
3756     if (!percentd_found)
3757         goto fail;
3758     *q = '\0';
3759     return 0;
3760  fail:
3761     *q = '\0';
3762     return -1;
3763 }
3764
3765 static void hex_dump_internal(void *avcl, FILE *f, int level,
3766                               const uint8_t *buf, int size)
3767 {
3768     int len, i, j, c;
3769 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3770
3771     for(i=0;i<size;i+=16) {
3772         len = size - i;
3773         if (len > 16)
3774             len = 16;
3775         PRINT("%08x ", i);
3776         for(j=0;j<16;j++) {
3777             if (j < len)
3778                 PRINT(" %02x", buf[i+j]);
3779             else
3780                 PRINT("   ");
3781         }
3782         PRINT(" ");
3783         for(j=0;j<len;j++) {
3784             c = buf[i+j];
3785             if (c < ' ' || c > '~')
3786                 c = '.';
3787             PRINT("%c", c);
3788         }
3789         PRINT("\n");
3790     }
3791 #undef PRINT
3792 }
3793
3794 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3795 {
3796     hex_dump_internal(NULL, f, 0, buf, size);
3797 }
3798
3799 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3800 {
3801     hex_dump_internal(avcl, NULL, level, buf, size);
3802 }
3803
3804 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3805 {
3806 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3807     PRINT("stream #%d:\n", pkt->stream_index);
3808     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3809     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3810     /* DTS is _always_ valid after av_read_frame() */
3811     PRINT("  dts=");
3812     if (pkt->dts == AV_NOPTS_VALUE)
3813         PRINT("N/A");
3814     else
3815         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3816     /* PTS may not be known if B-frames are present. */
3817     PRINT("  pts=");
3818     if (pkt->pts == AV_NOPTS_VALUE)
3819         PRINT("N/A");
3820     else
3821         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3822     PRINT("\n");
3823     PRINT("  size=%d\n", pkt->size);
3824 #undef PRINT
3825     if (dump_payload)
3826         av_hex_dump(f, pkt->data, pkt->size);
3827 }
3828
3829 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3830 {
3831     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3832 }
3833
3834 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3835                       AVStream *st)
3836 {
3837     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3838 }
3839
3840 void av_url_split(char *proto, int proto_size,
3841                   char *authorization, int authorization_size,
3842                   char *hostname, int hostname_size,
3843                   int *port_ptr,
3844                   char *path, int path_size,
3845                   const char *url)
3846 {
3847     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3848
3849     if (port_ptr)               *port_ptr = -1;
3850     if (proto_size > 0)         proto[0] = 0;
3851     if (authorization_size > 0) authorization[0] = 0;
3852     if (hostname_size > 0)      hostname[0] = 0;
3853     if (path_size > 0)          path[0] = 0;
3854
3855     /* parse protocol */
3856     if ((p = strchr(url, ':'))) {
3857         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3858         p++; /* skip ':' */
3859         if (*p == '/') p++;
3860         if (*p == '/') p++;
3861     } else {
3862         /* no protocol means plain filename */
3863         av_strlcpy(path, url, path_size);
3864         return;
3865     }
3866
3867     /* separate path from hostname */
3868     ls = strchr(p, '/');
3869     ls2 = strchr(p, '?');
3870     if(!ls)
3871         ls = ls2;
3872     else if (ls && ls2)
3873         ls = FFMIN(ls, ls2);
3874     if(ls)
3875         av_strlcpy(path, ls, path_size);
3876     else
3877         ls = &p[strlen(p)]; // XXX
3878
3879     /* the rest is hostname, use that to parse auth/port */
3880     if (ls != p) {
3881         /* authorization (user[:pass]@hostname) */
3882         at2 = p;
3883         while ((at = strchr(p, '@')) && at < ls) {
3884             av_strlcpy(authorization, at2,
3885                        FFMIN(authorization_size, at + 1 - at2));
3886             p = at + 1; /* skip '@' */
3887         }
3888
3889         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3890             /* [host]:port */
3891             av_strlcpy(hostname, p + 1,
3892                        FFMIN(hostname_size, brk - p));
3893             if (brk[1] == ':' && port_ptr)
3894                 *port_ptr = atoi(brk + 2);
3895         } else if ((col = strchr(p, ':')) && col < ls) {
3896             av_strlcpy(hostname, p,
3897                        FFMIN(col + 1 - p, hostname_size));
3898             if (port_ptr) *port_ptr = atoi(col + 1);
3899         } else
3900             av_strlcpy(hostname, p,
3901                        FFMIN(ls + 1 - p, hostname_size));
3902     }
3903 }
3904
3905 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3906 {
3907     int i;
3908     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3909                                            '4', '5', '6', '7',
3910                                            '8', '9', 'A', 'B',
3911                                            'C', 'D', 'E', 'F' };
3912     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3913                                            '4', '5', '6', '7',
3914                                            '8', '9', 'a', 'b',
3915                                            'c', 'd', 'e', 'f' };
3916     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3917
3918     for(i = 0; i < s; i++) {
3919         buff[i * 2]     = hex_table[src[i] >> 4];
3920         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3921     }
3922
3923     return buff;
3924 }
3925
3926 int ff_hex_to_data(uint8_t *data, const char *p)
3927 {
3928     int c, len, v;
3929
3930     len = 0;
3931     v = 1;
3932     for (;;) {
3933         p += strspn(p, SPACE_CHARS);
3934         if (*p == '\0')
3935             break;
3936         c = av_toupper((unsigned char) *p++);
3937         if (c >= '0' && c <= '9')
3938             c = c - '0';
3939         else if (c >= 'A' && c <= 'F')
3940             c = c - 'A' + 10;
3941         else
3942             break;
3943         v = (v << 4) | c;
3944         if (v & 0x100) {
3945             if (data)
3946                 data[len] = v;
3947             len++;
3948             v = 1;
3949         }
3950     }
3951     return len;
3952 }
3953
3954 #if FF_API_SET_PTS_INFO
3955 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3956                      unsigned int pts_num, unsigned int pts_den)
3957 {
3958     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3959 }
3960 #endif
3961
3962 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3963                          unsigned int pts_num, unsigned int pts_den)
3964 {
3965     AVRational new_tb;
3966     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3967         if(new_tb.num != pts_num)
3968             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3969     }else
3970         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3971
3972     if(new_tb.num <= 0 || new_tb.den <= 0) {
3973         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);
3974         return;
3975     }
3976     s->time_base = new_tb;
3977     av_codec_set_pkt_timebase(s->codec, new_tb);
3978     s->pts_wrap_bits = pts_wrap_bits;
3979 }
3980
3981 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3982                         void *context)
3983 {
3984     const char *ptr = str;
3985
3986     /* Parse key=value pairs. */
3987     for (;;) {
3988         const char *key;
3989         char *dest = NULL, *dest_end;
3990         int key_len, dest_len = 0;
3991
3992         /* Skip whitespace and potential commas. */
3993         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3994             ptr++;
3995         if (!*ptr)
3996             break;
3997
3998         key = ptr;
3999
4000         if (!(ptr = strchr(key, '=')))
4001             break;
4002         ptr++;
4003         key_len = ptr - key;
4004
4005         callback_get_buf(context, key, key_len, &dest, &dest_len);
4006         dest_end = dest + dest_len - 1;
4007
4008         if (*ptr == '\"') {
4009             ptr++;
4010             while (*ptr && *ptr != '\"') {
4011                 if (*ptr == '\\') {
4012                     if (!ptr[1])
4013                         break;
4014                     if (dest && dest < dest_end)
4015                         *dest++ = ptr[1];
4016                     ptr += 2;
4017                 } else {
4018                     if (dest && dest < dest_end)
4019                         *dest++ = *ptr;
4020                     ptr++;
4021                 }
4022             }
4023             if (*ptr == '\"')
4024                 ptr++;
4025         } else {
4026             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4027                 if (dest && dest < dest_end)
4028                     *dest++ = *ptr;
4029         }
4030         if (dest)
4031             *dest = 0;
4032     }
4033 }
4034
4035 int ff_find_stream_index(AVFormatContext *s, int id)
4036 {
4037     int i;
4038     for (i = 0; i < s->nb_streams; i++) {
4039         if (s->streams[i]->id == id)
4040             return i;
4041     }
4042     return -1;
4043 }
4044
4045 int64_t ff_iso8601_to_unix_time(const char *datestr)
4046 {
4047     struct tm time1 = {0}, time2 = {0};
4048     char *ret1, *ret2;
4049     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4050     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4051     if (ret2 && !ret1)
4052         return av_timegm(&time2);
4053     else
4054         return av_timegm(&time1);
4055 }
4056
4057 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4058 {
4059     if (ofmt) {
4060         if (ofmt->query_codec)
4061             return ofmt->query_codec(codec_id, std_compliance);
4062         else if (ofmt->codec_tag)
4063             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4064         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4065                  codec_id == ofmt->subtitle_codec)
4066             return 1;
4067     }
4068     return AVERROR_PATCHWELCOME;
4069 }
4070
4071 int avformat_network_init(void)
4072 {
4073 #if CONFIG_NETWORK
4074     int ret;
4075     ff_network_inited_globally = 1;
4076     if ((ret = ff_network_init()) < 0)
4077         return ret;
4078     ff_tls_init();
4079 #endif
4080     return 0;
4081 }
4082
4083 int avformat_network_deinit(void)
4084 {
4085 #if CONFIG_NETWORK
4086     ff_network_close();
4087     ff_tls_deinit();
4088 #endif
4089     return 0;
4090 }
4091
4092 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4093                         uint64_t channel_layout, int32_t sample_rate,
4094                         int32_t width, int32_t height)
4095 {
4096     uint32_t flags = 0;
4097     int size = 4;
4098     uint8_t *data;
4099     if (!pkt)
4100         return AVERROR(EINVAL);
4101     if (channels) {
4102         size += 4;
4103         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4104     }
4105     if (channel_layout) {
4106         size += 8;
4107         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4108     }
4109     if (sample_rate) {
4110         size += 4;
4111         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4112     }
4113     if (width || height) {
4114         size += 8;
4115         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4116     }
4117     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4118     if (!data)
4119         return AVERROR(ENOMEM);
4120     bytestream_put_le32(&data, flags);
4121     if (channels)
4122         bytestream_put_le32(&data, channels);
4123     if (channel_layout)
4124         bytestream_put_le64(&data, channel_layout);
4125     if (sample_rate)
4126         bytestream_put_le32(&data, sample_rate);
4127     if (width || height) {
4128         bytestream_put_le32(&data, width);
4129         bytestream_put_le32(&data, height);
4130     }
4131     return 0;
4132 }
4133
4134 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4135 {
4136     AVRational undef = {0, 1};
4137     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4138     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4139     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4140
4141     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4142                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4143     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4144         stream_sample_aspect_ratio = undef;
4145
4146     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4147                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4148     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4149         frame_sample_aspect_ratio = undef;
4150
4151     if (stream_sample_aspect_ratio.num)
4152         return stream_sample_aspect_ratio;
4153     else
4154         return frame_sample_aspect_ratio;
4155 }
4156
4157 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4158 {
4159     AVRational fr = st->r_frame_rate;
4160
4161     if (st->codec->ticks_per_frame > 1) {
4162         AVRational codec_fr = av_inv_q(st->codec->time_base);
4163         AVRational   avg_fr = st->avg_frame_rate;
4164         codec_fr.den *= st->codec->ticks_per_frame;
4165         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4166             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4167             fr = codec_fr;
4168     }
4169
4170     return fr;
4171 }
4172
4173 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4174                                     const char *spec)
4175 {
4176     if (*spec <= '9' && *spec >= '0') /* opt:index */
4177         return strtol(spec, NULL, 0) == st->index;
4178     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4179              *spec == 't') { /* opt:[vasdt] */
4180         enum AVMediaType type;
4181
4182         switch (*spec++) {
4183         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4184         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4185         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4186         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4187         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4188         default:  av_assert0(0);
4189         }
4190         if (type != st->codec->codec_type)
4191             return 0;
4192         if (*spec++ == ':') { /* possibly followed by :index */
4193             int i, index = strtol(spec, NULL, 0);
4194             for (i = 0; i < s->nb_streams; i++)
4195                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4196                    return i == st->index;
4197             return 0;
4198         }
4199         return 1;
4200     } else if (*spec == 'p' && *(spec + 1) == ':') {
4201         int prog_id, i, j;
4202         char *endptr;
4203         spec += 2;
4204         prog_id = strtol(spec, &endptr, 0);
4205         for (i = 0; i < s->nb_programs; i++) {
4206             if (s->programs[i]->id != prog_id)
4207                 continue;
4208
4209             if (*endptr++ == ':') {
4210                 int stream_idx = strtol(endptr, NULL, 0);
4211                 return stream_idx >= 0 &&
4212                     stream_idx < s->programs[i]->nb_stream_indexes &&
4213                     st->index == s->programs[i]->stream_index[stream_idx];
4214             }
4215
4216             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4217                 if (st->index == s->programs[i]->stream_index[j])
4218                     return 1;
4219         }
4220         return 0;
4221     } else if (*spec == '#') {
4222         int sid;
4223         char *endptr;
4224         sid = strtol(spec + 1, &endptr, 0);
4225         if (!*endptr)
4226             return st->id == sid;
4227     } else if (!*spec) /* empty specifier, matches everything */
4228         return 1;
4229
4230     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4231     return AVERROR(EINVAL);
4232 }
4233
4234 int ff_generate_avci_extradata(AVStream *st)
4235 {
4236     static const uint8_t avci100_1080p_extradata[] = {
4237         // SPS
4238         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4239         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4240         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4241         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4242         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4243         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4244         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4245         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4246         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4247         // PPS
4248         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4249         0xd0
4250     };
4251     static const uint8_t avci100_1080i_extradata[] = {
4252         // SPS
4253         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4254         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4255         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4256         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4257         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4258         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4259         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4260         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4261         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4262         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4263         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4264         // PPS
4265         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4266         0xd0
4267     };
4268     static const uint8_t avci50_1080i_extradata[] = {
4269         // SPS
4270         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4271         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4272         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4273         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4274         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4275         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4276         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4277         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4278         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4279         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4280         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4281         // PPS
4282         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4283         0x11
4284     };
4285     static const uint8_t avci100_720p_extradata[] = {
4286         // SPS
4287         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4288         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4289         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4290         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4291         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4292         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4293         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4294         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4295         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4296         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4297         // PPS
4298         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4299         0x11
4300     };
4301
4302     const uint8_t *data = NULL;
4303     int size = 0;
4304
4305     if (st->codec->width == 1920) {
4306         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4307             data = avci100_1080p_extradata;
4308             size = sizeof(avci100_1080p_extradata);
4309         } else {
4310             data = avci100_1080i_extradata;
4311             size = sizeof(avci100_1080i_extradata);
4312         }
4313     } else if (st->codec->width == 1440) {
4314         data = avci50_1080i_extradata;
4315         size = sizeof(avci50_1080i_extradata);
4316     } else if (st->codec->width == 1280) {
4317         data = avci100_720p_extradata;
4318         size = sizeof(avci100_720p_extradata);
4319     }
4320
4321     if (!size)
4322         return 0;
4323
4324     av_freep(&st->codec->extradata);
4325     if (ff_alloc_extradata(st->codec, size))
4326         return AVERROR(ENOMEM);
4327     memcpy(st->codec->extradata, data, size);
4328
4329     return 0;
4330 }