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 (decoder_ret) {
3267             decoder = find_decoder(ic, st, st->codec->codec_id);
3268             if (!decoder) {
3269                 if (ret < 0)
3270                     ret = AVERROR_DECODER_NOT_FOUND;
3271                 continue;
3272             }
3273         }
3274         count = st->codec_info_nb_frames;
3275         bitrate = avctx->bit_rate;
3276         multiframe = FFMIN(5, count);
3277         if ((best_multiframe >  multiframe) ||
3278             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3279             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3280             continue;
3281         best_count = count;
3282         best_bitrate = bitrate;
3283         best_multiframe = multiframe;
3284         ret = real_stream_index;
3285         best_decoder = decoder;
3286         if (program && i == nb_streams - 1 && ret < 0) {
3287             program = NULL;
3288             nb_streams = ic->nb_streams;
3289             i = 0; /* no related stream found, try again with everything */
3290         }
3291     }
3292     if (decoder_ret)
3293         *decoder_ret = best_decoder;
3294     return ret;
3295 }
3296
3297 /*******************************************************/
3298
3299 int av_read_play(AVFormatContext *s)
3300 {
3301     if (s->iformat->read_play)
3302         return s->iformat->read_play(s);
3303     if (s->pb)
3304         return avio_pause(s->pb, 0);
3305     return AVERROR(ENOSYS);
3306 }
3307
3308 int av_read_pause(AVFormatContext *s)
3309 {
3310     if (s->iformat->read_pause)
3311         return s->iformat->read_pause(s);
3312     if (s->pb)
3313         return avio_pause(s->pb, 1);
3314     return AVERROR(ENOSYS);
3315 }
3316
3317 void ff_free_stream(AVFormatContext *s, AVStream *st){
3318     av_assert0(s->nb_streams>0);
3319     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3320
3321     if (st->parser) {
3322         av_parser_close(st->parser);
3323     }
3324     if (st->attached_pic.data)
3325         av_free_packet(&st->attached_pic);
3326     av_dict_free(&st->metadata);
3327     av_freep(&st->probe_data.buf);
3328     av_freep(&st->index_entries);
3329     av_freep(&st->codec->extradata);
3330     av_freep(&st->codec->subtitle_header);
3331     av_freep(&st->codec);
3332     av_freep(&st->priv_data);
3333     if (st->info)
3334         av_freep(&st->info->duration_error);
3335     av_freep(&st->info);
3336     av_freep(&s->streams[ --s->nb_streams ]);
3337 }
3338
3339 void avformat_free_context(AVFormatContext *s)
3340 {
3341     int i;
3342
3343     if (!s)
3344         return;
3345
3346     av_opt_free(s);
3347     if (s->iformat && s->iformat->priv_class && s->priv_data)
3348         av_opt_free(s->priv_data);
3349
3350     for(i=s->nb_streams-1; i>=0; i--) {
3351         ff_free_stream(s, s->streams[i]);
3352     }
3353     for(i=s->nb_programs-1; i>=0; i--) {
3354         av_dict_free(&s->programs[i]->metadata);
3355         av_freep(&s->programs[i]->stream_index);
3356         av_freep(&s->programs[i]);
3357     }
3358     av_freep(&s->programs);
3359     av_freep(&s->priv_data);
3360     while(s->nb_chapters--) {
3361         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3362         av_freep(&s->chapters[s->nb_chapters]);
3363     }
3364     av_freep(&s->chapters);
3365     av_dict_free(&s->metadata);
3366     av_freep(&s->streams);
3367     av_free(s);
3368 }
3369
3370 #if FF_API_CLOSE_INPUT_FILE
3371 void av_close_input_file(AVFormatContext *s)
3372 {
3373     avformat_close_input(&s);
3374 }
3375 #endif
3376
3377 void avformat_close_input(AVFormatContext **ps)
3378 {
3379     AVFormatContext *s;
3380     AVIOContext *pb;
3381
3382     if (!ps || !*ps)
3383         return;
3384
3385     s = *ps;
3386     pb = s->pb;
3387
3388     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3389         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3390         pb = NULL;
3391
3392     flush_packet_queue(s);
3393
3394     if (s->iformat) {
3395         if (s->iformat->read_close)
3396             s->iformat->read_close(s);
3397     }
3398
3399     avformat_free_context(s);
3400
3401     *ps = NULL;
3402
3403     avio_close(pb);
3404 }
3405
3406 #if FF_API_NEW_STREAM
3407 AVStream *av_new_stream(AVFormatContext *s, int id)
3408 {
3409     AVStream *st = avformat_new_stream(s, NULL);
3410     if (st)
3411         st->id = id;
3412     return st;
3413 }
3414 #endif
3415
3416 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3417 {
3418     AVStream *st;
3419     int i;
3420     AVStream **streams;
3421
3422     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3423         return NULL;
3424     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3425     if (!streams)
3426         return NULL;
3427     s->streams = streams;
3428
3429     st = av_mallocz(sizeof(AVStream));
3430     if (!st)
3431         return NULL;
3432     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3433         av_free(st);
3434         return NULL;
3435     }
3436     st->info->last_dts = AV_NOPTS_VALUE;
3437
3438     st->codec = avcodec_alloc_context3(c);
3439     if (s->iformat) {
3440         /* no default bitrate if decoding */
3441         st->codec->bit_rate = 0;
3442     }
3443     st->index = s->nb_streams;
3444     st->start_time = AV_NOPTS_VALUE;
3445     st->duration = AV_NOPTS_VALUE;
3446         /* we set the current DTS to 0 so that formats without any timestamps
3447            but durations get some timestamps, formats with some unknown
3448            timestamps have their first few packets buffered and the
3449            timestamps corrected before they are returned to the user */
3450     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3451     st->first_dts = AV_NOPTS_VALUE;
3452     st->probe_packets = MAX_PROBE_PACKETS;
3453     st->pts_wrap_reference = AV_NOPTS_VALUE;
3454     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3455
3456     /* default pts setting is MPEG-like */
3457     avpriv_set_pts_info(st, 33, 1, 90000);
3458     st->last_IP_pts = AV_NOPTS_VALUE;
3459     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3460         st->pts_buffer[i]= AV_NOPTS_VALUE;
3461
3462     st->sample_aspect_ratio = (AVRational){0,1};
3463
3464 #if FF_API_R_FRAME_RATE
3465     st->info->last_dts      = AV_NOPTS_VALUE;
3466 #endif
3467     st->info->fps_first_dts = AV_NOPTS_VALUE;
3468     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3469
3470     s->streams[s->nb_streams++] = st;
3471     return st;
3472 }
3473
3474 AVProgram *av_new_program(AVFormatContext *ac, int id)
3475 {
3476     AVProgram *program=NULL;
3477     int i;
3478
3479     av_dlog(ac, "new_program: id=0x%04x\n", id);
3480
3481     for(i=0; i<ac->nb_programs; i++)
3482         if(ac->programs[i]->id == id)
3483             program = ac->programs[i];
3484
3485     if(!program){
3486         program = av_mallocz(sizeof(AVProgram));
3487         if (!program)
3488             return NULL;
3489         dynarray_add(&ac->programs, &ac->nb_programs, program);
3490         program->discard = AVDISCARD_NONE;
3491     }
3492     program->id = id;
3493     program->pts_wrap_reference = AV_NOPTS_VALUE;
3494     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3495
3496     program->start_time =
3497     program->end_time   = AV_NOPTS_VALUE;
3498
3499     return program;
3500 }
3501
3502 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3503 {
3504     AVChapter *chapter = NULL;
3505     int i;
3506
3507     for(i=0; i<s->nb_chapters; i++)
3508         if(s->chapters[i]->id == id)
3509             chapter = s->chapters[i];
3510
3511     if(!chapter){
3512         chapter= av_mallocz(sizeof(AVChapter));
3513         if(!chapter)
3514             return NULL;
3515         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3516     }
3517     av_dict_set(&chapter->metadata, "title", title, 0);
3518     chapter->id    = id;
3519     chapter->time_base= time_base;
3520     chapter->start = start;
3521     chapter->end   = end;
3522
3523     return chapter;
3524 }
3525
3526 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3527 {
3528     int i, j;
3529     AVProgram *program=NULL;
3530     void *tmp;
3531
3532     if (idx >= ac->nb_streams) {
3533         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3534         return;
3535     }
3536
3537     for(i=0; i<ac->nb_programs; i++){
3538         if(ac->programs[i]->id != progid)
3539             continue;
3540         program = ac->programs[i];
3541         for(j=0; j<program->nb_stream_indexes; j++)
3542             if(program->stream_index[j] == idx)
3543                 return;
3544
3545         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3546         if(!tmp)
3547             return;
3548         program->stream_index = tmp;
3549         program->stream_index[program->nb_stream_indexes++] = idx;
3550         return;
3551     }
3552 }
3553
3554 static void print_fps(double d, const char *postfix){
3555     uint64_t v= lrintf(d*100);
3556     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3557     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3558     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3559 }
3560
3561 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3562 {
3563     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3564         AVDictionaryEntry *tag=NULL;
3565
3566         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3567         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3568             if(strcmp("language", tag->key)){
3569                 const char *p = tag->value;
3570                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3571                 while(*p) {
3572                     char tmp[256];
3573                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3574                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3575                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3576                     p += len;
3577                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3578                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3579                     if (*p) p++;
3580                 }
3581                 av_log(ctx, AV_LOG_INFO, "\n");
3582             }
3583         }
3584     }
3585 }
3586
3587 /* "user interface" functions */
3588 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3589 {
3590     char buf[256];
3591     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3592     AVStream *st = ic->streams[i];
3593     int g = av_gcd(st->time_base.num, st->time_base.den);
3594     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3595     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3596     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3597     /* the pid is an important information, so we display it */
3598     /* XXX: add a generic system */
3599     if (flags & AVFMT_SHOW_IDS)
3600         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3601     if (lang)
3602         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3603     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3604     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3605     if (st->sample_aspect_ratio.num && // default
3606         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3607         AVRational display_aspect_ratio;
3608         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3609                   st->codec->width*st->sample_aspect_ratio.num,
3610                   st->codec->height*st->sample_aspect_ratio.den,
3611                   1024*1024);
3612         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3613                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3614                  display_aspect_ratio.num, display_aspect_ratio.den);
3615     }
3616     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3617         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3618             print_fps(av_q2d(st->avg_frame_rate), "fps");
3619 #if FF_API_R_FRAME_RATE
3620         if(st->r_frame_rate.den && st->r_frame_rate.num)
3621             print_fps(av_q2d(st->r_frame_rate), "tbr");
3622 #endif
3623         if(st->time_base.den && st->time_base.num)
3624             print_fps(1/av_q2d(st->time_base), "tbn");
3625         if(st->codec->time_base.den && st->codec->time_base.num)
3626             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3627     }
3628     if (st->disposition & AV_DISPOSITION_DEFAULT)
3629         av_log(NULL, AV_LOG_INFO, " (default)");
3630     if (st->disposition & AV_DISPOSITION_DUB)
3631         av_log(NULL, AV_LOG_INFO, " (dub)");
3632     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3633         av_log(NULL, AV_LOG_INFO, " (original)");
3634     if (st->disposition & AV_DISPOSITION_COMMENT)
3635         av_log(NULL, AV_LOG_INFO, " (comment)");
3636     if (st->disposition & AV_DISPOSITION_LYRICS)
3637         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3638     if (st->disposition & AV_DISPOSITION_KARAOKE)
3639         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3640     if (st->disposition & AV_DISPOSITION_FORCED)
3641         av_log(NULL, AV_LOG_INFO, " (forced)");
3642     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3643         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3644     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3645         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3646     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3647         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3648     av_log(NULL, AV_LOG_INFO, "\n");
3649     dump_metadata(NULL, st->metadata, "    ");
3650 }
3651
3652 void av_dump_format(AVFormatContext *ic,
3653                     int index,
3654                     const char *url,
3655                     int is_output)
3656 {
3657     int i;
3658     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3659     if (ic->nb_streams && !printed)
3660         return;
3661
3662     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3663             is_output ? "Output" : "Input",
3664             index,
3665             is_output ? ic->oformat->name : ic->iformat->name,
3666             is_output ? "to" : "from", url);
3667     dump_metadata(NULL, ic->metadata, "  ");
3668     if (!is_output) {
3669         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3670         if (ic->duration != AV_NOPTS_VALUE) {
3671             int hours, mins, secs, us;
3672             int64_t duration = ic->duration + 5000;
3673             secs = duration / AV_TIME_BASE;
3674             us = duration % AV_TIME_BASE;
3675             mins = secs / 60;
3676             secs %= 60;
3677             hours = mins / 60;
3678             mins %= 60;
3679             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3680                    (100 * us) / AV_TIME_BASE);
3681         } else {
3682             av_log(NULL, AV_LOG_INFO, "N/A");
3683         }
3684         if (ic->start_time != AV_NOPTS_VALUE) {
3685             int secs, us;
3686             av_log(NULL, AV_LOG_INFO, ", start: ");
3687             secs = ic->start_time / AV_TIME_BASE;
3688             us = abs(ic->start_time % AV_TIME_BASE);
3689             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3690                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3691         }
3692         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3693         if (ic->bit_rate) {
3694             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3695         } else {
3696             av_log(NULL, AV_LOG_INFO, "N/A");
3697         }
3698         av_log(NULL, AV_LOG_INFO, "\n");
3699     }
3700     for (i = 0; i < ic->nb_chapters; i++) {
3701         AVChapter *ch = ic->chapters[i];
3702         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3703         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3704         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3705
3706         dump_metadata(NULL, ch->metadata, "    ");
3707     }
3708     if(ic->nb_programs) {
3709         int j, k, total = 0;
3710         for(j=0; j<ic->nb_programs; j++) {
3711             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3712                                                   "name", NULL, 0);
3713             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3714                    name ? name->value : "");
3715             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3716             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3717                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3718                 printed[ic->programs[j]->stream_index[k]] = 1;
3719             }
3720             total += ic->programs[j]->nb_stream_indexes;
3721         }
3722         if (total < ic->nb_streams)
3723             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3724     }
3725     for(i=0;i<ic->nb_streams;i++)
3726         if (!printed[i])
3727             dump_stream_format(ic, i, index, is_output);
3728
3729     av_free(printed);
3730 }
3731
3732 uint64_t ff_ntp_time(void)
3733 {
3734   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3735 }
3736
3737 int av_get_frame_filename(char *buf, int buf_size,
3738                           const char *path, int number)
3739 {
3740     const char *p;
3741     char *q, buf1[20], c;
3742     int nd, len, percentd_found;
3743
3744     q = buf;
3745     p = path;
3746     percentd_found = 0;
3747     for(;;) {
3748         c = *p++;
3749         if (c == '\0')
3750             break;
3751         if (c == '%') {
3752             do {
3753                 nd = 0;
3754                 while (av_isdigit(*p)) {
3755                     nd = nd * 10 + *p++ - '0';
3756                 }
3757                 c = *p++;
3758             } while (av_isdigit(c));
3759
3760             switch(c) {
3761             case '%':
3762                 goto addchar;
3763             case 'd':
3764                 if (percentd_found)
3765                     goto fail;
3766                 percentd_found = 1;
3767                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3768                 len = strlen(buf1);
3769                 if ((q - buf + len) > buf_size - 1)
3770                     goto fail;
3771                 memcpy(q, buf1, len);
3772                 q += len;
3773                 break;
3774             default:
3775                 goto fail;
3776             }
3777         } else {
3778         addchar:
3779             if ((q - buf) < buf_size - 1)
3780                 *q++ = c;
3781         }
3782     }
3783     if (!percentd_found)
3784         goto fail;
3785     *q = '\0';
3786     return 0;
3787  fail:
3788     *q = '\0';
3789     return -1;
3790 }
3791
3792 static void hex_dump_internal(void *avcl, FILE *f, int level,
3793                               const uint8_t *buf, int size)
3794 {
3795     int len, i, j, c;
3796 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3797
3798     for(i=0;i<size;i+=16) {
3799         len = size - i;
3800         if (len > 16)
3801             len = 16;
3802         PRINT("%08x ", i);
3803         for(j=0;j<16;j++) {
3804             if (j < len)
3805                 PRINT(" %02x", buf[i+j]);
3806             else
3807                 PRINT("   ");
3808         }
3809         PRINT(" ");
3810         for(j=0;j<len;j++) {
3811             c = buf[i+j];
3812             if (c < ' ' || c > '~')
3813                 c = '.';
3814             PRINT("%c", c);
3815         }
3816         PRINT("\n");
3817     }
3818 #undef PRINT
3819 }
3820
3821 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3822 {
3823     hex_dump_internal(NULL, f, 0, buf, size);
3824 }
3825
3826 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3827 {
3828     hex_dump_internal(avcl, NULL, level, buf, size);
3829 }
3830
3831 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3832 {
3833 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3834     PRINT("stream #%d:\n", pkt->stream_index);
3835     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3836     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3837     /* DTS is _always_ valid after av_read_frame() */
3838     PRINT("  dts=");
3839     if (pkt->dts == AV_NOPTS_VALUE)
3840         PRINT("N/A");
3841     else
3842         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3843     /* PTS may not be known if B-frames are present. */
3844     PRINT("  pts=");
3845     if (pkt->pts == AV_NOPTS_VALUE)
3846         PRINT("N/A");
3847     else
3848         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3849     PRINT("\n");
3850     PRINT("  size=%d\n", pkt->size);
3851 #undef PRINT
3852     if (dump_payload)
3853         av_hex_dump(f, pkt->data, pkt->size);
3854 }
3855
3856 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3857 {
3858     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3859 }
3860
3861 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3862                       AVStream *st)
3863 {
3864     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3865 }
3866
3867 void av_url_split(char *proto, int proto_size,
3868                   char *authorization, int authorization_size,
3869                   char *hostname, int hostname_size,
3870                   int *port_ptr,
3871                   char *path, int path_size,
3872                   const char *url)
3873 {
3874     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3875
3876     if (port_ptr)               *port_ptr = -1;
3877     if (proto_size > 0)         proto[0] = 0;
3878     if (authorization_size > 0) authorization[0] = 0;
3879     if (hostname_size > 0)      hostname[0] = 0;
3880     if (path_size > 0)          path[0] = 0;
3881
3882     /* parse protocol */
3883     if ((p = strchr(url, ':'))) {
3884         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3885         p++; /* skip ':' */
3886         if (*p == '/') p++;
3887         if (*p == '/') p++;
3888     } else {
3889         /* no protocol means plain filename */
3890         av_strlcpy(path, url, path_size);
3891         return;
3892     }
3893
3894     /* separate path from hostname */
3895     ls = strchr(p, '/');
3896     ls2 = strchr(p, '?');
3897     if(!ls)
3898         ls = ls2;
3899     else if (ls && ls2)
3900         ls = FFMIN(ls, ls2);
3901     if(ls)
3902         av_strlcpy(path, ls, path_size);
3903     else
3904         ls = &p[strlen(p)]; // XXX
3905
3906     /* the rest is hostname, use that to parse auth/port */
3907     if (ls != p) {
3908         /* authorization (user[:pass]@hostname) */
3909         at2 = p;
3910         while ((at = strchr(p, '@')) && at < ls) {
3911             av_strlcpy(authorization, at2,
3912                        FFMIN(authorization_size, at + 1 - at2));
3913             p = at + 1; /* skip '@' */
3914         }
3915
3916         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3917             /* [host]:port */
3918             av_strlcpy(hostname, p + 1,
3919                        FFMIN(hostname_size, brk - p));
3920             if (brk[1] == ':' && port_ptr)
3921                 *port_ptr = atoi(brk + 2);
3922         } else if ((col = strchr(p, ':')) && col < ls) {
3923             av_strlcpy(hostname, p,
3924                        FFMIN(col + 1 - p, hostname_size));
3925             if (port_ptr) *port_ptr = atoi(col + 1);
3926         } else
3927             av_strlcpy(hostname, p,
3928                        FFMIN(ls + 1 - p, hostname_size));
3929     }
3930 }
3931
3932 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3933 {
3934     int i;
3935     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3936                                            '4', '5', '6', '7',
3937                                            '8', '9', 'A', 'B',
3938                                            'C', 'D', 'E', 'F' };
3939     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3940                                            '4', '5', '6', '7',
3941                                            '8', '9', 'a', 'b',
3942                                            'c', 'd', 'e', 'f' };
3943     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3944
3945     for(i = 0; i < s; i++) {
3946         buff[i * 2]     = hex_table[src[i] >> 4];
3947         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3948     }
3949
3950     return buff;
3951 }
3952
3953 int ff_hex_to_data(uint8_t *data, const char *p)
3954 {
3955     int c, len, v;
3956
3957     len = 0;
3958     v = 1;
3959     for (;;) {
3960         p += strspn(p, SPACE_CHARS);
3961         if (*p == '\0')
3962             break;
3963         c = av_toupper((unsigned char) *p++);
3964         if (c >= '0' && c <= '9')
3965             c = c - '0';
3966         else if (c >= 'A' && c <= 'F')
3967             c = c - 'A' + 10;
3968         else
3969             break;
3970         v = (v << 4) | c;
3971         if (v & 0x100) {
3972             if (data)
3973                 data[len] = v;
3974             len++;
3975             v = 1;
3976         }
3977     }
3978     return len;
3979 }
3980
3981 #if FF_API_SET_PTS_INFO
3982 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3983                      unsigned int pts_num, unsigned int pts_den)
3984 {
3985     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3986 }
3987 #endif
3988
3989 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3990                          unsigned int pts_num, unsigned int pts_den)
3991 {
3992     AVRational new_tb;
3993     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3994         if(new_tb.num != pts_num)
3995             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3996     }else
3997         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3998
3999     if(new_tb.num <= 0 || new_tb.den <= 0) {
4000         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);
4001         return;
4002     }
4003     s->time_base = new_tb;
4004     av_codec_set_pkt_timebase(s->codec, new_tb);
4005     s->pts_wrap_bits = pts_wrap_bits;
4006 }
4007
4008 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4009                         void *context)
4010 {
4011     const char *ptr = str;
4012
4013     /* Parse key=value pairs. */
4014     for (;;) {
4015         const char *key;
4016         char *dest = NULL, *dest_end;
4017         int key_len, dest_len = 0;
4018
4019         /* Skip whitespace and potential commas. */
4020         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4021             ptr++;
4022         if (!*ptr)
4023             break;
4024
4025         key = ptr;
4026
4027         if (!(ptr = strchr(key, '=')))
4028             break;
4029         ptr++;
4030         key_len = ptr - key;
4031
4032         callback_get_buf(context, key, key_len, &dest, &dest_len);
4033         dest_end = dest + dest_len - 1;
4034
4035         if (*ptr == '\"') {
4036             ptr++;
4037             while (*ptr && *ptr != '\"') {
4038                 if (*ptr == '\\') {
4039                     if (!ptr[1])
4040                         break;
4041                     if (dest && dest < dest_end)
4042                         *dest++ = ptr[1];
4043                     ptr += 2;
4044                 } else {
4045                     if (dest && dest < dest_end)
4046                         *dest++ = *ptr;
4047                     ptr++;
4048                 }
4049             }
4050             if (*ptr == '\"')
4051                 ptr++;
4052         } else {
4053             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4054                 if (dest && dest < dest_end)
4055                     *dest++ = *ptr;
4056         }
4057         if (dest)
4058             *dest = 0;
4059     }
4060 }
4061
4062 int ff_find_stream_index(AVFormatContext *s, int id)
4063 {
4064     int i;
4065     for (i = 0; i < s->nb_streams; i++) {
4066         if (s->streams[i]->id == id)
4067             return i;
4068     }
4069     return -1;
4070 }
4071
4072 int64_t ff_iso8601_to_unix_time(const char *datestr)
4073 {
4074     struct tm time1 = {0}, time2 = {0};
4075     char *ret1, *ret2;
4076     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4077     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4078     if (ret2 && !ret1)
4079         return av_timegm(&time2);
4080     else
4081         return av_timegm(&time1);
4082 }
4083
4084 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4085 {
4086     if (ofmt) {
4087         if (ofmt->query_codec)
4088             return ofmt->query_codec(codec_id, std_compliance);
4089         else if (ofmt->codec_tag)
4090             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4091         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4092                  codec_id == ofmt->subtitle_codec)
4093             return 1;
4094     }
4095     return AVERROR_PATCHWELCOME;
4096 }
4097
4098 int avformat_network_init(void)
4099 {
4100 #if CONFIG_NETWORK
4101     int ret;
4102     ff_network_inited_globally = 1;
4103     if ((ret = ff_network_init()) < 0)
4104         return ret;
4105     ff_tls_init();
4106 #endif
4107     return 0;
4108 }
4109
4110 int avformat_network_deinit(void)
4111 {
4112 #if CONFIG_NETWORK
4113     ff_network_close();
4114     ff_tls_deinit();
4115 #endif
4116     return 0;
4117 }
4118
4119 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4120                         uint64_t channel_layout, int32_t sample_rate,
4121                         int32_t width, int32_t height)
4122 {
4123     uint32_t flags = 0;
4124     int size = 4;
4125     uint8_t *data;
4126     if (!pkt)
4127         return AVERROR(EINVAL);
4128     if (channels) {
4129         size += 4;
4130         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4131     }
4132     if (channel_layout) {
4133         size += 8;
4134         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4135     }
4136     if (sample_rate) {
4137         size += 4;
4138         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4139     }
4140     if (width || height) {
4141         size += 8;
4142         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4143     }
4144     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4145     if (!data)
4146         return AVERROR(ENOMEM);
4147     bytestream_put_le32(&data, flags);
4148     if (channels)
4149         bytestream_put_le32(&data, channels);
4150     if (channel_layout)
4151         bytestream_put_le64(&data, channel_layout);
4152     if (sample_rate)
4153         bytestream_put_le32(&data, sample_rate);
4154     if (width || height) {
4155         bytestream_put_le32(&data, width);
4156         bytestream_put_le32(&data, height);
4157     }
4158     return 0;
4159 }
4160
4161 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4162 {
4163     AVRational undef = {0, 1};
4164     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4165     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4166     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4167
4168     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4169                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4170     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4171         stream_sample_aspect_ratio = undef;
4172
4173     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4174                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4175     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4176         frame_sample_aspect_ratio = undef;
4177
4178     if (stream_sample_aspect_ratio.num)
4179         return stream_sample_aspect_ratio;
4180     else
4181         return frame_sample_aspect_ratio;
4182 }
4183
4184 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4185 {
4186     AVRational fr = st->r_frame_rate;
4187
4188     if (st->codec->ticks_per_frame > 1) {
4189         AVRational codec_fr = av_inv_q(st->codec->time_base);
4190         AVRational   avg_fr = st->avg_frame_rate;
4191         codec_fr.den *= st->codec->ticks_per_frame;
4192         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4193             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4194             fr = codec_fr;
4195     }
4196
4197     return fr;
4198 }
4199
4200 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4201                                     const char *spec)
4202 {
4203     if (*spec <= '9' && *spec >= '0') /* opt:index */
4204         return strtol(spec, NULL, 0) == st->index;
4205     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4206              *spec == 't') { /* opt:[vasdt] */
4207         enum AVMediaType type;
4208
4209         switch (*spec++) {
4210         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4211         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4212         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4213         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4214         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4215         default:  av_assert0(0);
4216         }
4217         if (type != st->codec->codec_type)
4218             return 0;
4219         if (*spec++ == ':') { /* possibly followed by :index */
4220             int i, index = strtol(spec, NULL, 0);
4221             for (i = 0; i < s->nb_streams; i++)
4222                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4223                    return i == st->index;
4224             return 0;
4225         }
4226         return 1;
4227     } else if (*spec == 'p' && *(spec + 1) == ':') {
4228         int prog_id, i, j;
4229         char *endptr;
4230         spec += 2;
4231         prog_id = strtol(spec, &endptr, 0);
4232         for (i = 0; i < s->nb_programs; i++) {
4233             if (s->programs[i]->id != prog_id)
4234                 continue;
4235
4236             if (*endptr++ == ':') {
4237                 int stream_idx = strtol(endptr, NULL, 0);
4238                 return stream_idx >= 0 &&
4239                     stream_idx < s->programs[i]->nb_stream_indexes &&
4240                     st->index == s->programs[i]->stream_index[stream_idx];
4241             }
4242
4243             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4244                 if (st->index == s->programs[i]->stream_index[j])
4245                     return 1;
4246         }
4247         return 0;
4248     } else if (*spec == '#') {
4249         int sid;
4250         char *endptr;
4251         sid = strtol(spec + 1, &endptr, 0);
4252         if (!*endptr)
4253             return st->id == sid;
4254     } else if (!*spec) /* empty specifier, matches everything */
4255         return 1;
4256
4257     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4258     return AVERROR(EINVAL);
4259 }
4260
4261 int ff_generate_avci_extradata(AVStream *st)
4262 {
4263     static const uint8_t avci100_1080p_extradata[] = {
4264         // SPS
4265         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4266         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4267         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4268         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4269         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4270         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4271         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4272         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4273         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4274         // PPS
4275         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4276         0xd0
4277     };
4278     static const uint8_t avci100_1080i_extradata[] = {
4279         // SPS
4280         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4281         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4282         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4283         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4284         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4285         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4286         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4287         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4288         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4289         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4290         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4291         // PPS
4292         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4293         0xd0
4294     };
4295     static const uint8_t avci50_1080i_extradata[] = {
4296         // SPS
4297         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4298         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4299         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4300         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4301         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4302         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4303         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4304         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4305         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4306         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4307         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4308         // PPS
4309         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4310         0x11
4311     };
4312     static const uint8_t avci100_720p_extradata[] = {
4313         // SPS
4314         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4315         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4316         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4317         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4318         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4319         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4320         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4321         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4322         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4323         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4324         // PPS
4325         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4326         0x11
4327     };
4328
4329     const uint8_t *data = NULL;
4330     int size = 0;
4331
4332     if (st->codec->width == 1920) {
4333         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4334             data = avci100_1080p_extradata;
4335             size = sizeof(avci100_1080p_extradata);
4336         } else {
4337             data = avci100_1080i_extradata;
4338             size = sizeof(avci100_1080i_extradata);
4339         }
4340     } else if (st->codec->width == 1440) {
4341         data = avci50_1080i_extradata;
4342         size = sizeof(avci50_1080i_extradata);
4343     } else if (st->codec->width == 1280) {
4344         data = avci100_720p_extradata;
4345         size = sizeof(avci100_720p_extradata);
4346     }
4347
4348     if (!size)
4349         return 0;
4350
4351     av_freep(&st->codec->extradata);
4352     if (ff_alloc_extradata(st->codec, size))
4353         return AVERROR(ENOMEM);
4354     memcpy(st->codec->extradata, data, size);
4355
4356     return 0;
4357 }