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

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