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