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

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