libavformat/utils.c

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