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