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 (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1043         //FIXME Set low_delay = 0 when has_b_frames = 1
1044         st->codec->has_b_frames = 1;
1045
1046     /* do we have a video B-frame ? */
1047     delay= st->codec->has_b_frames;
1048     presentation_delayed = 0;
1049
1050     /* XXX: need has_b_frame, but cannot get it if the codec is
1051         not initialized */
1052     if (delay &&
1053         pc && pc->pict_type != AV_PICTURE_TYPE_B)
1054         presentation_delayed = 1;
1055
1056     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1057         st->pts_wrap_bits < 63 &&
1058         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1059         if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1060             pkt->dts -= 1LL<<st->pts_wrap_bits;
1061         } else
1062             pkt->pts += 1LL<<st->pts_wrap_bits;
1063     }
1064
1065     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1066     // we take the conservative approach and discard both
1067     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1068     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1069         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1070         if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1071             pkt->dts= AV_NOPTS_VALUE;
1072     }
1073
1074     if (pkt->duration == 0) {
1075         ff_compute_frame_duration(&num, &den, st, pc, pkt);
1076         if (den && num) {
1077             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1078         }
1079     }
1080     if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1081         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1082
1083     /* correct timestamps with byte offset if demuxers only have timestamps
1084        on packet boundaries */
1085     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1086         /* this will estimate bitrate based on this frame's duration and size */
1087         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1088         if(pkt->pts != AV_NOPTS_VALUE)
1089             pkt->pts += offset;
1090         if(pkt->dts != AV_NOPTS_VALUE)
1091             pkt->dts += offset;
1092     }
1093
1094     /* This may be redundant, but it should not hurt. */
1095     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1096         presentation_delayed = 1;
1097
1098     av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1099            presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1100     /* interpolate PTS and DTS if they are not present */
1101     //We skip H264 currently because delay and has_b_frames are not reliably set
1102     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1103         if (presentation_delayed) {
1104             /* DTS = decompression timestamp */
1105             /* PTS = presentation timestamp */
1106             if (pkt->dts == AV_NOPTS_VALUE)
1107                 pkt->dts = st->last_IP_pts;
1108             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1109             if (pkt->dts == AV_NOPTS_VALUE)
1110                 pkt->dts = st->cur_dts;
1111
1112             /* this is tricky: the dts must be incremented by the duration
1113             of the frame we are displaying, i.e. the last I- or P-frame */
1114             if (st->last_IP_duration == 0)
1115                 st->last_IP_duration = pkt->duration;
1116             if(pkt->dts != AV_NOPTS_VALUE)
1117                 st->cur_dts = pkt->dts + st->last_IP_duration;
1118             st->last_IP_duration  = pkt->duration;
1119             st->last_IP_pts= pkt->pts;
1120             /* cannot compute PTS if not present (we can compute it only
1121             by knowing the future */
1122         } else if (pkt->pts != AV_NOPTS_VALUE ||
1123                    pkt->dts != AV_NOPTS_VALUE ||
1124                    pkt->duration                ) {
1125             int duration = pkt->duration;
1126
1127             /* presentation is not delayed : PTS and DTS are the same */
1128             if (pkt->pts == AV_NOPTS_VALUE)
1129                 pkt->pts = pkt->dts;
1130             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1131                                       pkt->pts, pkt);
1132             if (pkt->pts == AV_NOPTS_VALUE)
1133                 pkt->pts = st->cur_dts;
1134             pkt->dts = pkt->pts;
1135             if (pkt->pts != AV_NOPTS_VALUE)
1136                 st->cur_dts = pkt->pts + duration;
1137         }
1138     }
1139
1140     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1141         st->pts_buffer[0]= pkt->pts;
1142         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1143             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1144         if(pkt->dts == AV_NOPTS_VALUE)
1145             pkt->dts= st->pts_buffer[0];
1146     }
1147     if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1148         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1149     }
1150     if(pkt->dts > st->cur_dts)
1151         st->cur_dts = pkt->dts;
1152
1153     av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1154             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1155
1156     /* update flags */
1157     if (is_intra_only(st->codec))
1158         pkt->flags |= AV_PKT_FLAG_KEY;
1159     if (pc)
1160         pkt->convergence_duration = pc->convergence_duration;
1161 }
1162
1163 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1164 {
1165     while (*pkt_buf) {
1166         AVPacketList *pktl = *pkt_buf;
1167         *pkt_buf = pktl->next;
1168         av_free_packet(&pktl->pkt);
1169         av_freep(&pktl);
1170     }
1171     *pkt_buf_end = NULL;
1172 }
1173
1174 /**
1175  * Parse a packet, add all split parts to parse_queue
1176  *
1177  * @param pkt packet to parse, NULL when flushing the parser at end of stream
1178  */
1179 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1180 {
1181     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1182     AVStream     *st = s->streams[stream_index];
1183     uint8_t    *data = pkt ? pkt->data : NULL;
1184     int         size = pkt ? pkt->size : 0;
1185     int ret = 0, got_output = 0;
1186
1187     if (!pkt) {
1188         av_init_packet(&flush_pkt);
1189         pkt = &flush_pkt;
1190         got_output = 1;
1191     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1192         // preserve 0-size sync packets
1193         compute_pkt_fields(s, st, st->parser, pkt);
1194     }
1195
1196     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1197         int len;
1198
1199         av_init_packet(&out_pkt);
1200         len = av_parser_parse2(st->parser,  st->codec,
1201                                &out_pkt.data, &out_pkt.size, data, size,
1202                                pkt->pts, pkt->dts, pkt->pos);
1203
1204         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1205         pkt->pos = -1;
1206         /* increment read pointer */
1207         data += len;
1208         size -= len;
1209
1210         got_output = !!out_pkt.size;
1211
1212         if (!out_pkt.size)
1213             continue;
1214
1215         if (pkt->side_data) {
1216             out_pkt.side_data       = pkt->side_data;
1217             out_pkt.side_data_elems = pkt->side_data_elems;
1218             pkt->side_data       = NULL;
1219             pkt->side_data_elems = 0;
1220         }
1221
1222         /* set the duration */
1223         out_pkt.duration = 0;
1224         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1225             if (st->codec->sample_rate > 0) {
1226                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1227                                                     (AVRational){ 1, st->codec->sample_rate },
1228                                                     st->time_base,
1229                                                     AV_ROUND_DOWN);
1230             }
1231         } else if (st->codec->time_base.num != 0 &&
1232                    st->codec->time_base.den != 0) {
1233             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1234                                                 st->codec->time_base,
1235                                                 st->time_base,
1236                                                 AV_ROUND_DOWN);
1237         }
1238
1239         out_pkt.stream_index = st->index;
1240         out_pkt.pts = st->parser->pts;
1241         out_pkt.dts = st->parser->dts;
1242         out_pkt.pos = st->parser->pos;
1243
1244         if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1245             out_pkt.pos = st->parser->frame_offset;
1246
1247         if (st->parser->key_frame == 1 ||
1248             (st->parser->key_frame == -1 &&
1249              st->parser->pict_type == AV_PICTURE_TYPE_I))
1250             out_pkt.flags |= AV_PKT_FLAG_KEY;
1251
1252         if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1253             out_pkt.flags |= AV_PKT_FLAG_KEY;
1254
1255         compute_pkt_fields(s, st, st->parser, &out_pkt);
1256
1257         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1258             out_pkt.buf   = pkt->buf;
1259             pkt->buf      = NULL;
1260 #if FF_API_DESTRUCT_PACKET
1261 FF_DISABLE_DEPRECATION_WARNINGS
1262             out_pkt.destruct = pkt->destruct;
1263             pkt->destruct = NULL;
1264 FF_ENABLE_DEPRECATION_WARNINGS
1265 #endif
1266         }
1267         if ((ret = av_dup_packet(&out_pkt)) < 0)
1268             goto fail;
1269
1270         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1271             av_free_packet(&out_pkt);
1272             ret = AVERROR(ENOMEM);
1273             goto fail;
1274         }
1275     }
1276
1277
1278     /* end of the stream => close and free the parser */
1279     if (pkt == &flush_pkt) {
1280         av_parser_close(st->parser);
1281         st->parser = NULL;
1282     }
1283
1284 fail:
1285     av_free_packet(pkt);
1286     return ret;
1287 }
1288
1289 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1290                                    AVPacketList **pkt_buffer_end,
1291                                    AVPacket      *pkt)
1292 {
1293     AVPacketList *pktl;
1294     av_assert0(*pkt_buffer);
1295     pktl = *pkt_buffer;
1296     *pkt = pktl->pkt;
1297     *pkt_buffer = pktl->next;
1298     if (!pktl->next)
1299         *pkt_buffer_end = NULL;
1300     av_freep(&pktl);
1301     return 0;
1302 }
1303
1304 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1305 {
1306     int ret = 0, i, got_packet = 0;
1307
1308     av_init_packet(pkt);
1309
1310     while (!got_packet && !s->parse_queue) {
1311         AVStream *st;
1312         AVPacket cur_pkt;
1313
1314         /* read next packet */
1315         ret = ff_read_packet(s, &cur_pkt);
1316         if (ret < 0) {
1317             if (ret == AVERROR(EAGAIN))
1318                 return ret;
1319             /* flush the parsers */
1320             for(i = 0; i < s->nb_streams; i++) {
1321                 st = s->streams[i];
1322                 if (st->parser && st->need_parsing)
1323                     parse_packet(s, NULL, st->index);
1324             }
1325             /* all remaining packets are now in parse_queue =>
1326              * really terminate parsing */
1327             break;
1328         }
1329         ret = 0;
1330         st  = s->streams[cur_pkt.stream_index];
1331
1332         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1333             cur_pkt.dts != AV_NOPTS_VALUE &&
1334             cur_pkt.pts < cur_pkt.dts) {
1335             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1336                    cur_pkt.stream_index,
1337                    av_ts2str(cur_pkt.pts),
1338                    av_ts2str(cur_pkt.dts),
1339                    cur_pkt.size);
1340         }
1341         if (s->debug & FF_FDEBUG_TS)
1342             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1343                    cur_pkt.stream_index,
1344                    av_ts2str(cur_pkt.pts),
1345                    av_ts2str(cur_pkt.dts),
1346                    cur_pkt.size,
1347                    cur_pkt.duration,
1348                    cur_pkt.flags);
1349
1350         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1351             st->parser = av_parser_init(st->codec->codec_id);
1352             if (!st->parser) {
1353                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1354                        "%s, packets or times may be invalid.\n",
1355                        avcodec_get_name(st->codec->codec_id));
1356                 /* no parser available: just output the raw packets */
1357                 st->need_parsing = AVSTREAM_PARSE_NONE;
1358             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1359                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1360             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1361                 st->parser->flags |= PARSER_FLAG_ONCE;
1362             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1363                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1364             }
1365         }
1366
1367         if (!st->need_parsing || !st->parser) {
1368             /* no parsing needed: we just output the packet as is */
1369             *pkt = cur_pkt;
1370             compute_pkt_fields(s, st, NULL, pkt);
1371             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1372                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1373                 ff_reduce_index(s, st->index);
1374                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1375             }
1376             got_packet = 1;
1377         } else if (st->discard < AVDISCARD_ALL) {
1378             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1379                 return ret;
1380         } else {
1381             /* free packet */
1382             av_free_packet(&cur_pkt);
1383         }
1384         if (pkt->flags & AV_PKT_FLAG_KEY)
1385             st->skip_to_keyframe = 0;
1386         if (st->skip_to_keyframe) {
1387             av_free_packet(&cur_pkt);
1388             if (got_packet) {
1389                 *pkt = cur_pkt;
1390             }
1391             got_packet = 0;
1392         }
1393     }
1394
1395     if (!got_packet && s->parse_queue)
1396         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1397
1398     if(s->debug & FF_FDEBUG_TS)
1399         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1400             pkt->stream_index,
1401             av_ts2str(pkt->pts),
1402             av_ts2str(pkt->dts),
1403             pkt->size,
1404             pkt->duration,
1405             pkt->flags);
1406
1407     return ret;
1408 }
1409
1410 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1411 {
1412     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1413     int          eof = 0;
1414     int ret;
1415     AVStream *st;
1416
1417     if (!genpts) {
1418         ret = s->packet_buffer ?
1419             read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1420             read_frame_internal(s, pkt);
1421         if (ret < 0)
1422             return ret;
1423         goto return_packet;
1424     }
1425
1426     for (;;) {
1427         AVPacketList *pktl = s->packet_buffer;
1428
1429         if (pktl) {
1430             AVPacket *next_pkt = &pktl->pkt;
1431
1432             if (next_pkt->dts != AV_NOPTS_VALUE) {
1433                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1434                 // last dts seen for this stream. if any of packets following
1435                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1436                 int64_t last_dts = next_pkt->dts;
1437                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1438                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1439                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1440                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1441                             next_pkt->pts = pktl->pkt.dts;
1442                         }
1443                         if (last_dts != AV_NOPTS_VALUE) {
1444                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1445                             last_dts = pktl->pkt.dts;
1446                         }
1447                     }
1448                     pktl = pktl->next;
1449                 }
1450                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1451                     // Fixing the last reference frame had none pts issue (For MXF etc).
1452                     // We only do this when
1453                     // 1. eof.
1454                     // 2. we are not able to resolve a pts value for current packet.
1455                     // 3. the packets for this stream at the end of the files had valid dts.
1456                     next_pkt->pts = last_dts + next_pkt->duration;
1457                 }
1458                 pktl = s->packet_buffer;
1459             }
1460
1461             /* read packet from packet buffer, if there is data */
1462             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1463                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1464                 ret = read_from_packet_buffer(&s->packet_buffer,
1465                                                &s->packet_buffer_end, pkt);
1466                 goto return_packet;
1467             }
1468         }
1469
1470         ret = read_frame_internal(s, pkt);
1471         if (ret < 0) {
1472             if (pktl && ret != AVERROR(EAGAIN)) {
1473                 eof = 1;
1474                 continue;
1475             } else
1476                 return ret;
1477         }
1478
1479         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1480                           &s->packet_buffer_end)) < 0)
1481             return AVERROR(ENOMEM);
1482     }
1483
1484 return_packet:
1485
1486     st = s->streams[pkt->stream_index];
1487     if (st->skip_samples) {
1488         uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1489         if (p) {
1490             AV_WL32(p, st->skip_samples);
1491             av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1492         }
1493         st->skip_samples = 0;
1494     }
1495
1496     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1497         ff_reduce_index(s, st->index);
1498         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1499     }
1500
1501     if (is_relative(pkt->dts))
1502         pkt->dts -= RELATIVE_TS_BASE;
1503     if (is_relative(pkt->pts))
1504         pkt->pts -= RELATIVE_TS_BASE;
1505
1506     return ret;
1507 }
1508
1509 /* XXX: suppress the packet queue */
1510 static void flush_packet_queue(AVFormatContext *s)
1511 {
1512     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1513     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1514     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1515
1516     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1517 }
1518
1519 /*******************************************************/
1520 /* seek support */
1521
1522 int av_find_default_stream_index(AVFormatContext *s)
1523 {
1524     int first_audio_index = -1;
1525     int i;
1526     AVStream *st;
1527
1528     if (s->nb_streams <= 0)
1529         return -1;
1530     for(i = 0; i < s->nb_streams; i++) {
1531         st = s->streams[i];
1532         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1533             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1534             return i;
1535         }
1536         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1537             first_audio_index = i;
1538     }
1539     return first_audio_index >= 0 ? first_audio_index : 0;
1540 }
1541
1542 /**
1543  * Flush the frame reader.
1544  */
1545 void ff_read_frame_flush(AVFormatContext *s)
1546 {
1547     AVStream *st;
1548     int i, j;
1549
1550     flush_packet_queue(s);
1551
1552     /* for each stream, reset read state */
1553     for(i = 0; i < s->nb_streams; i++) {
1554         st = s->streams[i];
1555
1556         if (st->parser) {
1557             av_parser_close(st->parser);
1558             st->parser = NULL;
1559         }
1560         st->last_IP_pts = AV_NOPTS_VALUE;
1561         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1562         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1563
1564         st->probe_packets = MAX_PROBE_PACKETS;
1565
1566         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1567             st->pts_buffer[j]= AV_NOPTS_VALUE;
1568     }
1569 }
1570
1571 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1572 {
1573     int i;
1574
1575     for(i = 0; i < s->nb_streams; i++) {
1576         AVStream *st = s->streams[i];
1577
1578         st->cur_dts = av_rescale(timestamp,
1579                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1580                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1581     }
1582 }
1583
1584 void ff_reduce_index(AVFormatContext *s, int stream_index)
1585 {
1586     AVStream *st= s->streams[stream_index];
1587     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1588
1589     if((unsigned)st->nb_index_entries >= max_entries){
1590         int i;
1591         for(i=0; 2*i<st->nb_index_entries; i++)
1592             st->index_entries[i]= st->index_entries[2*i];
1593         st->nb_index_entries= i;
1594     }
1595 }
1596
1597 int ff_add_index_entry(AVIndexEntry **index_entries,
1598                        int *nb_index_entries,
1599                        unsigned int *index_entries_allocated_size,
1600                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1601 {
1602     AVIndexEntry *entries, *ie;
1603     int index;
1604
1605     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1606         return -1;
1607
1608     if(timestamp == AV_NOPTS_VALUE)
1609         return AVERROR(EINVAL);
1610
1611     if (size < 0 || size > 0x3FFFFFFF)
1612         return AVERROR(EINVAL);
1613
1614     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1615         timestamp -= RELATIVE_TS_BASE;
1616
1617     entries = av_fast_realloc(*index_entries,
1618                               index_entries_allocated_size,
1619                               (*nb_index_entries + 1) *
1620                               sizeof(AVIndexEntry));
1621     if(!entries)
1622         return -1;
1623
1624     *index_entries= entries;
1625
1626     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1627
1628     if(index<0){
1629         index= (*nb_index_entries)++;
1630         ie= &entries[index];
1631         av_assert0(index==0 || ie[-1].timestamp < timestamp);
1632     }else{
1633         ie= &entries[index];
1634         if(ie->timestamp != timestamp){
1635             if(ie->timestamp <= timestamp)
1636                 return -1;
1637             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1638             (*nb_index_entries)++;
1639         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1640             distance= ie->min_distance;
1641     }
1642
1643     ie->pos = pos;
1644     ie->timestamp = timestamp;
1645     ie->min_distance= distance;
1646     ie->size= size;
1647     ie->flags = flags;
1648
1649     return index;
1650 }
1651
1652 int av_add_index_entry(AVStream *st,
1653                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1654 {
1655     timestamp = wrap_timestamp(st, timestamp);
1656     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1657                               &st->index_entries_allocated_size, pos,
1658                               timestamp, size, distance, flags);
1659 }
1660
1661 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1662                               int64_t wanted_timestamp, int flags)
1663 {
1664     int a, b, m;
1665     int64_t timestamp;
1666
1667     a = - 1;
1668     b = nb_entries;
1669
1670     //optimize appending index entries at the end
1671     if(b && entries[b-1].timestamp < wanted_timestamp)
1672         a= b-1;
1673
1674     while (b - a > 1) {
1675         m = (a + b) >> 1;
1676         timestamp = entries[m].timestamp;
1677         if(timestamp >= wanted_timestamp)
1678             b = m;
1679         if(timestamp <= wanted_timestamp)
1680             a = m;
1681     }
1682     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1683
1684     if(!(flags & AVSEEK_FLAG_ANY)){
1685         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1686             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1687         }
1688     }
1689
1690     if(m == nb_entries)
1691         return -1;
1692     return  m;
1693 }
1694
1695 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1696                               int flags)
1697 {
1698     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1699                                      wanted_timestamp, flags);
1700 }
1701
1702 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1703                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1704 {
1705     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1706     if (stream_index >= 0)
1707         ts = wrap_timestamp(s->streams[stream_index], ts);
1708     return ts;
1709 }
1710
1711 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1712 {
1713     AVInputFormat *avif= s->iformat;
1714     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1715     int64_t ts_min, ts_max, ts;
1716     int index;
1717     int64_t ret;
1718     AVStream *st;
1719
1720     if (stream_index < 0)
1721         return -1;
1722
1723     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1724
1725     ts_max=
1726     ts_min= AV_NOPTS_VALUE;
1727     pos_limit= -1; //gcc falsely says it may be uninitialized
1728
1729     st= s->streams[stream_index];
1730     if(st->index_entries){
1731         AVIndexEntry *e;
1732
1733         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()
1734         index= FFMAX(index, 0);
1735         e= &st->index_entries[index];
1736
1737         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1738             pos_min= e->pos;
1739             ts_min= e->timestamp;
1740             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1741                     pos_min, av_ts2str(ts_min));
1742         }else{
1743             av_assert1(index==0);
1744         }
1745
1746         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1747         av_assert0(index < st->nb_index_entries);
1748         if(index >= 0){
1749             e= &st->index_entries[index];
1750             av_assert1(e->timestamp >= target_ts);
1751             pos_max= e->pos;
1752             ts_max= e->timestamp;
1753             pos_limit= pos_max - e->min_distance;
1754             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1755                     pos_max, pos_limit, av_ts2str(ts_max));
1756         }
1757     }
1758
1759     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1760     if(pos<0)
1761         return -1;
1762
1763     /* do the seek */
1764     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1765         return ret;
1766
1767     ff_read_frame_flush(s);
1768     ff_update_cur_dts(s, st, ts);
1769
1770     return 0;
1771 }
1772
1773 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1774                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1775 {
1776     int64_t step= 1024;
1777     int64_t limit, ts_max;
1778     int64_t filesize = avio_size(s->pb);
1779     int64_t pos_max = filesize - 1;
1780     do{
1781         limit = pos_max;
1782         pos_max = FFMAX(0, (pos_max) - step);
1783         ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1784         step += step;
1785     }while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1786     if (ts_max == AV_NOPTS_VALUE)
1787         return -1;
1788
1789     for(;;){
1790         int64_t tmp_pos = pos_max + 1;
1791         int64_t tmp_ts = ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1792         if(tmp_ts == AV_NOPTS_VALUE)
1793             break;
1794         av_assert0(tmp_pos > pos_max);
1795         ts_max  = tmp_ts;
1796         pos_max = tmp_pos;
1797         if(tmp_pos >= filesize)
1798             break;
1799     }
1800
1801     if (ts)
1802         *ts = ts_max;
1803     if (pos)
1804         *pos = pos_max;
1805
1806     return 0;
1807 }
1808
1809 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1810                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1811                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1812                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1813 {
1814     int64_t pos, ts;
1815     int64_t start_pos;
1816     int no_change;
1817     int ret;
1818
1819     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1820
1821     if(ts_min == AV_NOPTS_VALUE){
1822         pos_min = s->data_offset;
1823         ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1824         if (ts_min == AV_NOPTS_VALUE)
1825             return -1;
1826     }
1827
1828     if(ts_min >= target_ts){
1829         *ts_ret= ts_min;
1830         return pos_min;
1831     }
1832
1833     if(ts_max == AV_NOPTS_VALUE){
1834         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1835             return ret;
1836         pos_limit= pos_max;
1837     }
1838
1839     if(ts_max <= target_ts){
1840         *ts_ret= ts_max;
1841         return pos_max;
1842     }
1843
1844     if(ts_min > ts_max){
1845         return -1;
1846     }else if(ts_min == ts_max){
1847         pos_limit= pos_min;
1848     }
1849
1850     no_change=0;
1851     while (pos_min < pos_limit) {
1852         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1853                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1854         assert(pos_limit <= pos_max);
1855
1856         if(no_change==0){
1857             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1858             // interpolate position (better than dichotomy)
1859             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1860                 + pos_min - approximate_keyframe_distance;
1861         }else if(no_change==1){
1862             // bisection, if interpolation failed to change min or max pos last time
1863             pos = (pos_min + pos_limit)>>1;
1864         }else{
1865             /* linear search if bisection failed, can only happen if there
1866                are very few or no keyframes between min/max */
1867             pos=pos_min;
1868         }
1869         if(pos <= pos_min)
1870             pos= pos_min + 1;
1871         else if(pos > pos_limit)
1872             pos= pos_limit;
1873         start_pos= pos;
1874
1875         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1876         if(pos == pos_max)
1877             no_change++;
1878         else
1879             no_change=0;
1880         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1881                 pos_min, pos, pos_max,
1882                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1883                 pos_limit, start_pos, no_change);
1884         if(ts == AV_NOPTS_VALUE){
1885             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1886             return -1;
1887         }
1888         assert(ts != AV_NOPTS_VALUE);
1889         if (target_ts <= ts) {
1890             pos_limit = start_pos - 1;
1891             pos_max = pos;
1892             ts_max = ts;
1893         }
1894         if (target_ts >= ts) {
1895             pos_min = pos;
1896             ts_min = ts;
1897         }
1898     }
1899
1900     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1901     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1902 #if 0
1903     pos_min = pos;
1904     ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1905     pos_min++;
1906     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1907     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1908             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1909 #endif
1910     *ts_ret= ts;
1911     return pos;
1912 }
1913
1914 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1915     int64_t pos_min, pos_max;
1916
1917     pos_min = s->data_offset;
1918     pos_max = avio_size(s->pb) - 1;
1919
1920     if     (pos < pos_min) pos= pos_min;
1921     else if(pos > pos_max) pos= pos_max;
1922
1923     avio_seek(s->pb, pos, SEEK_SET);
1924
1925     s->io_repositioned = 1;
1926
1927     return 0;
1928 }
1929
1930 static int seek_frame_generic(AVFormatContext *s,
1931                                  int stream_index, int64_t timestamp, int flags)
1932 {
1933     int index;
1934     int64_t ret;
1935     AVStream *st;
1936     AVIndexEntry *ie;
1937
1938     st = s->streams[stream_index];
1939
1940     index = av_index_search_timestamp(st, timestamp, flags);
1941
1942     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1943         return -1;
1944
1945     if(index < 0 || index==st->nb_index_entries-1){
1946         AVPacket pkt;
1947         int nonkey=0;
1948
1949         if(st->nb_index_entries){
1950             av_assert0(st->index_entries);
1951             ie= &st->index_entries[st->nb_index_entries-1];
1952             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1953                 return ret;
1954             ff_update_cur_dts(s, st, ie->timestamp);
1955         }else{
1956             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1957                 return ret;
1958         }
1959         for (;;) {
1960             int read_status;
1961             do{
1962                 read_status = av_read_frame(s, &pkt);
1963             } while (read_status == AVERROR(EAGAIN));
1964             if (read_status < 0)
1965                 break;
1966             av_free_packet(&pkt);
1967             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1968                 if(pkt.flags & AV_PKT_FLAG_KEY)
1969                     break;
1970                 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1971                     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);
1972                     break;
1973                 }
1974             }
1975         }
1976         index = av_index_search_timestamp(st, timestamp, flags);
1977     }
1978     if (index < 0)
1979         return -1;
1980
1981     ff_read_frame_flush(s);
1982     if (s->iformat->read_seek){
1983         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1984             return 0;
1985     }
1986     ie = &st->index_entries[index];
1987     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1988         return ret;
1989     ff_update_cur_dts(s, st, ie->timestamp);
1990
1991     return 0;
1992 }
1993
1994 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1995                                int64_t timestamp, int flags)
1996 {
1997     int ret;
1998     AVStream *st;
1999
2000     if (flags & AVSEEK_FLAG_BYTE) {
2001         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2002             return -1;
2003         ff_read_frame_flush(s);
2004         return seek_frame_byte(s, stream_index, timestamp, flags);
2005     }
2006
2007     if(stream_index < 0){
2008         stream_index= av_find_default_stream_index(s);
2009         if(stream_index < 0)
2010             return -1;
2011
2012         st= s->streams[stream_index];
2013         /* timestamp for default must be expressed in AV_TIME_BASE units */
2014         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2015     }
2016
2017     /* first, we try the format specific seek */
2018     if (s->iformat->read_seek) {
2019         ff_read_frame_flush(s);
2020         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2021     } else
2022         ret = -1;
2023     if (ret >= 0) {
2024         return 0;
2025     }
2026
2027     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2028         ff_read_frame_flush(s);
2029         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2030     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2031         ff_read_frame_flush(s);
2032         return seek_frame_generic(s, stream_index, timestamp, flags);
2033     }
2034     else
2035         return -1;
2036 }
2037
2038 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2039 {
2040     int ret;
2041
2042     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2043         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2044         if ((flags & AVSEEK_FLAG_BACKWARD))
2045             max_ts = timestamp;
2046         else
2047             min_ts = timestamp;
2048         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2049                                   flags & ~AVSEEK_FLAG_BACKWARD);
2050     }
2051
2052     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2053
2054     if (ret >= 0)
2055         ret = avformat_queue_attached_pictures(s);
2056
2057     return ret;
2058 }
2059
2060 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2061 {
2062     if(min_ts > ts || max_ts < ts)
2063         return -1;
2064     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2065         return AVERROR(EINVAL);
2066
2067     if(s->seek2any>0)
2068         flags |= AVSEEK_FLAG_ANY;
2069     flags &= ~AVSEEK_FLAG_BACKWARD;
2070
2071     if (s->iformat->read_seek2) {
2072         int ret;
2073         ff_read_frame_flush(s);
2074
2075         if (stream_index == -1 && s->nb_streams == 1) {
2076             AVRational time_base = s->streams[0]->time_base;
2077             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2078             min_ts = av_rescale_rnd(min_ts, time_base.den,
2079                                     time_base.num * (int64_t)AV_TIME_BASE,
2080                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2081             max_ts = av_rescale_rnd(max_ts, time_base.den,
2082                                     time_base.num * (int64_t)AV_TIME_BASE,
2083                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2084         }
2085
2086         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2087
2088         if (ret >= 0)
2089             ret = avformat_queue_attached_pictures(s);
2090         return ret;
2091     }
2092
2093     if(s->iformat->read_timestamp){
2094         //try to seek via read_timestamp()
2095     }
2096
2097     // Fall back on old API if new is not implemented but old is.
2098     // Note the old API has somewhat different semantics.
2099     if (s->iformat->read_seek || 1) {
2100         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2101         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2102         if (ret<0 && ts != min_ts && max_ts != ts) {
2103             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2104             if (ret >= 0)
2105                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2106         }
2107         return ret;
2108     }
2109
2110     // try some generic seek like seek_frame_generic() but with new ts semantics
2111     return -1; //unreachable
2112 }
2113
2114 /*******************************************************/
2115
2116 /**
2117  * Return TRUE if the stream has accurate duration in any stream.
2118  *
2119  * @return TRUE if the stream has accurate duration for at least one component.
2120  */
2121 static int has_duration(AVFormatContext *ic)
2122 {
2123     int i;
2124     AVStream *st;
2125
2126     for(i = 0;i < ic->nb_streams; i++) {
2127         st = ic->streams[i];
2128         if (st->duration != AV_NOPTS_VALUE)
2129             return 1;
2130     }
2131     if (ic->duration != AV_NOPTS_VALUE)
2132         return 1;
2133     return 0;
2134 }
2135
2136 /**
2137  * Estimate the stream timings from the one of each components.
2138  *
2139  * Also computes the global bitrate if possible.
2140  */
2141 static void update_stream_timings(AVFormatContext *ic)
2142 {
2143     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2144     int64_t duration, duration1, filesize;
2145     int i;
2146     AVStream *st;
2147     AVProgram *p;
2148
2149     start_time = INT64_MAX;
2150     start_time_text = INT64_MAX;
2151     end_time = INT64_MIN;
2152     duration = INT64_MIN;
2153     for(i = 0;i < ic->nb_streams; i++) {
2154         st = ic->streams[i];
2155         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2156             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2157             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2158                 if (start_time1 < start_time_text)
2159                     start_time_text = start_time1;
2160             } else
2161                 start_time = FFMIN(start_time, start_time1);
2162             end_time1 = AV_NOPTS_VALUE;
2163             if (st->duration != AV_NOPTS_VALUE) {
2164                 end_time1 = start_time1
2165                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2166                 end_time = FFMAX(end_time, end_time1);
2167             }
2168             for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2169                 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2170                     p->start_time = start_time1;
2171                 if(p->end_time < end_time1)
2172                     p->end_time = end_time1;
2173             }
2174         }
2175         if (st->duration != AV_NOPTS_VALUE) {
2176             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2177             duration = FFMAX(duration, duration1);
2178         }
2179     }
2180     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2181         start_time = start_time_text;
2182     else if(start_time > start_time_text)
2183         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2184
2185     if (start_time != INT64_MAX) {
2186         ic->start_time = start_time;
2187         if (end_time != INT64_MIN) {
2188             if (ic->nb_programs) {
2189                 for (i=0; i<ic->nb_programs; i++) {
2190                     p = ic->programs[i];
2191                     if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2192                         duration = FFMAX(duration, p->end_time - p->start_time);
2193                 }
2194             } else
2195                 duration = FFMAX(duration, end_time - start_time);
2196         }
2197     }
2198     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2199         ic->duration = duration;
2200     }
2201         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2202             /* compute the bitrate */
2203             double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2204                 (double)ic->duration;
2205             if (bitrate >= 0 && bitrate <= INT_MAX)
2206                 ic->bit_rate = bitrate;
2207         }
2208 }
2209
2210 static void fill_all_stream_timings(AVFormatContext *ic)
2211 {
2212     int i;
2213     AVStream *st;
2214
2215     update_stream_timings(ic);
2216     for(i = 0;i < ic->nb_streams; i++) {
2217         st = ic->streams[i];
2218         if (st->start_time == AV_NOPTS_VALUE) {
2219             if(ic->start_time != AV_NOPTS_VALUE)
2220                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2221             if(ic->duration != AV_NOPTS_VALUE)
2222                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2223         }
2224     }
2225 }
2226
2227 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2228 {
2229     int64_t filesize, duration;
2230     int i, show_warning = 0;
2231     AVStream *st;
2232
2233     /* if bit_rate is already set, we believe it */
2234     if (ic->bit_rate <= 0) {
2235         int bit_rate = 0;
2236         for(i=0;i<ic->nb_streams;i++) {
2237             st = ic->streams[i];
2238             if (st->codec->bit_rate > 0) {
2239                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2240                     bit_rate = 0;
2241                     break;
2242                 }
2243                 bit_rate += st->codec->bit_rate;
2244             }
2245         }
2246         ic->bit_rate = bit_rate;
2247     }
2248
2249     /* if duration is already set, we believe it */
2250     if (ic->duration == AV_NOPTS_VALUE &&
2251         ic->bit_rate != 0) {
2252         filesize = ic->pb ? avio_size(ic->pb) : 0;
2253         if (filesize > 0) {
2254             for(i = 0; i < ic->nb_streams; i++) {
2255                 st = ic->streams[i];
2256                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2257                     && st->duration == AV_NOPTS_VALUE) {
2258                     duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2259                     st->duration = duration;
2260                     show_warning = 1;
2261                 }
2262             }
2263         }
2264     }
2265     if (show_warning)
2266         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2267 }
2268
2269 #define DURATION_MAX_READ_SIZE 250000LL
2270 #define DURATION_MAX_RETRY 4
2271
2272 /* only usable for MPEG-PS streams */
2273 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2274 {
2275     AVPacket pkt1, *pkt = &pkt1;
2276     AVStream *st;
2277     int read_size, i, ret;
2278     int64_t end_time;
2279     int64_t filesize, offset, duration;
2280     int retry=0;
2281
2282     /* flush packet queue */
2283     flush_packet_queue(ic);
2284
2285     for (i=0; i<ic->nb_streams; i++) {
2286         st = ic->streams[i];
2287         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2288             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2289
2290         if (st->parser) {
2291             av_parser_close(st->parser);
2292             st->parser= NULL;
2293         }
2294     }
2295
2296     /* estimate the end time (duration) */
2297     /* XXX: may need to support wrapping */
2298     filesize = ic->pb ? avio_size(ic->pb) : 0;
2299     end_time = AV_NOPTS_VALUE;
2300     do{
2301         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2302         if (offset < 0)
2303             offset = 0;
2304
2305         avio_seek(ic->pb, offset, SEEK_SET);
2306         read_size = 0;
2307         for(;;) {
2308             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2309                 break;
2310
2311             do {
2312                 ret = ff_read_packet(ic, pkt);
2313             } while(ret == AVERROR(EAGAIN));
2314             if (ret != 0)
2315                 break;
2316             read_size += pkt->size;
2317             st = ic->streams[pkt->stream_index];
2318             if (pkt->pts != AV_NOPTS_VALUE &&
2319                 (st->start_time != AV_NOPTS_VALUE ||
2320                  st->first_dts  != AV_NOPTS_VALUE)) {
2321                 duration = end_time = pkt->pts;
2322                 if (st->start_time != AV_NOPTS_VALUE)
2323                     duration -= st->start_time;
2324                 else
2325                     duration -= st->first_dts;
2326                 if (duration > 0) {
2327                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2328                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2329                         st->duration = duration;
2330                     st->info->last_duration = duration;
2331                 }
2332             }
2333             av_free_packet(pkt);
2334         }
2335     }while(   end_time==AV_NOPTS_VALUE
2336            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2337            && ++retry <= DURATION_MAX_RETRY);
2338
2339     fill_all_stream_timings(ic);
2340
2341     avio_seek(ic->pb, old_offset, SEEK_SET);
2342     for (i=0; i<ic->nb_streams; i++) {
2343         st= ic->streams[i];
2344         st->cur_dts= st->first_dts;
2345         st->last_IP_pts = AV_NOPTS_VALUE;
2346     }
2347 }
2348
2349 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2350 {
2351     int64_t file_size;
2352
2353     /* get the file size, if possible */
2354     if (ic->iformat->flags & AVFMT_NOFILE) {
2355         file_size = 0;
2356     } else {
2357         file_size = avio_size(ic->pb);
2358         file_size = FFMAX(0, file_size);
2359     }
2360
2361     if ((!strcmp(ic->iformat->name, "mpeg") ||
2362          !strcmp(ic->iformat->name, "mpegts")) &&
2363         file_size && ic->pb->seekable) {
2364         /* get accurate estimate from the PTSes */
2365         estimate_timings_from_pts(ic, old_offset);
2366         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2367     } else if (has_duration(ic)) {
2368         /* at least one component has timings - we use them for all
2369            the components */
2370         fill_all_stream_timings(ic);
2371         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2372     } else {
2373         /* less precise: use bitrate info */
2374         estimate_timings_from_bit_rate(ic);
2375         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2376     }
2377     update_stream_timings(ic);
2378
2379     {
2380         int i;
2381         AVStream av_unused *st;
2382         for(i = 0;i < ic->nb_streams; i++) {
2383             st = ic->streams[i];
2384             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2385                     (double) st->start_time / AV_TIME_BASE,
2386                     (double) st->duration   / AV_TIME_BASE);
2387         }
2388         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2389                 (double) ic->start_time / AV_TIME_BASE,
2390                 (double) ic->duration   / AV_TIME_BASE,
2391                 ic->bit_rate / 1000);
2392     }
2393 }
2394
2395 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2396 {
2397     AVCodecContext *avctx = st->codec;
2398
2399 #define FAIL(errmsg) do {                                         \
2400         if (errmsg_ptr)                                           \
2401             *errmsg_ptr = errmsg;                                 \
2402         return 0;                                                 \
2403     } while (0)
2404
2405     switch (avctx->codec_type) {
2406     case AVMEDIA_TYPE_AUDIO:
2407         if (!avctx->frame_size && determinable_frame_size(avctx))
2408             FAIL("unspecified frame size");
2409         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2410             FAIL("unspecified sample format");
2411         if (!avctx->sample_rate)
2412             FAIL("unspecified sample rate");
2413         if (!avctx->channels)
2414             FAIL("unspecified number of channels");
2415         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2416             FAIL("no decodable DTS frames");
2417         break;
2418     case AVMEDIA_TYPE_VIDEO:
2419         if (!avctx->width)
2420             FAIL("unspecified size");
2421         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2422             FAIL("unspecified pixel format");
2423         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2424             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2425                 FAIL("no frame in rv30/40 and no sar");
2426         break;
2427     case AVMEDIA_TYPE_SUBTITLE:
2428         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2429             FAIL("unspecified size");
2430         break;
2431     case AVMEDIA_TYPE_DATA:
2432         if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2433     }
2434
2435     if (avctx->codec_id == AV_CODEC_ID_NONE)
2436         FAIL("unknown codec");
2437     return 1;
2438 }
2439
2440 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2441 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
2442 {
2443     const AVCodec *codec;
2444     int got_picture = 1, ret = 0;
2445     AVFrame *frame = avcodec_alloc_frame();
2446     AVSubtitle subtitle;
2447     AVPacket pkt = *avpkt;
2448
2449     if (!frame)
2450         return AVERROR(ENOMEM);
2451
2452     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2453         AVDictionary *thread_opt = NULL;
2454
2455         codec = find_decoder(s, st, st->codec->codec_id);
2456
2457         if (!codec) {
2458             st->info->found_decoder = -1;
2459             ret = -1;
2460             goto fail;
2461         }
2462
2463         /* force thread count to 1 since the h264 decoder will not extract SPS
2464          *  and PPS to extradata during multi-threaded decoding */
2465         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2466         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2467         if (!options)
2468             av_dict_free(&thread_opt);
2469         if (ret < 0) {
2470             st->info->found_decoder = -1;
2471             goto fail;
2472         }
2473         st->info->found_decoder = 1;
2474     } else if (!st->info->found_decoder)
2475         st->info->found_decoder = 1;
2476
2477     if (st->info->found_decoder < 0) {
2478         ret = -1;
2479         goto fail;
2480     }
2481
2482     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2483            ret >= 0 &&
2484            (!has_codec_parameters(st, NULL)   ||
2485            !has_decode_delay_been_guessed(st) ||
2486            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2487         got_picture = 0;
2488         avcodec_get_frame_defaults(frame);
2489         switch(st->codec->codec_type) {
2490         case AVMEDIA_TYPE_VIDEO:
2491             ret = avcodec_decode_video2(st->codec, frame,
2492                                         &got_picture, &pkt);
2493             break;
2494         case AVMEDIA_TYPE_AUDIO:
2495             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2496             break;
2497         case AVMEDIA_TYPE_SUBTITLE:
2498             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2499                                            &got_picture, &pkt);
2500             ret = pkt.size;
2501             break;
2502         default:
2503             break;
2504         }
2505         if (ret >= 0) {
2506             if (got_picture)
2507                 st->nb_decoded_frames++;
2508             pkt.data += ret;
2509             pkt.size -= ret;
2510             ret       = got_picture;
2511         }
2512     }
2513
2514     if(!pkt.data && !got_picture)
2515         ret = -1;
2516
2517 fail:
2518     avcodec_free_frame(&frame);
2519     return ret;
2520 }
2521
2522 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2523 {
2524     while (tags->id != AV_CODEC_ID_NONE) {
2525         if (tags->id == id)
2526             return tags->tag;
2527         tags++;
2528     }
2529     return 0;
2530 }
2531
2532 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2533 {
2534     int i;
2535     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2536         if(tag == tags[i].tag)
2537             return tags[i].id;
2538     }
2539     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2540         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2541             return tags[i].id;
2542     }
2543     return AV_CODEC_ID_NONE;
2544 }
2545
2546 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2547 {
2548     if (flt) {
2549         switch (bps) {
2550         case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2551         case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2552         default: return AV_CODEC_ID_NONE;
2553         }
2554     } else {
2555         bps  += 7;
2556         bps >>= 3;
2557         if (sflags & (1 << (bps - 1))) {
2558             switch (bps) {
2559             case 1:  return AV_CODEC_ID_PCM_S8;
2560             case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2561             case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2562             case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2563             default: return AV_CODEC_ID_NONE;
2564             }
2565         } else {
2566             switch (bps) {
2567             case 1:  return AV_CODEC_ID_PCM_U8;
2568             case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2569             case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2570             case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2571             default: return AV_CODEC_ID_NONE;
2572             }
2573         }
2574     }
2575 }
2576
2577 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2578 {
2579     unsigned int tag;
2580     if (!av_codec_get_tag2(tags, id, &tag))
2581         return 0;
2582     return tag;
2583 }
2584
2585 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2586                       unsigned int *tag)
2587 {
2588     int i;
2589     for(i=0; tags && tags[i]; i++){
2590         const AVCodecTag *codec_tags = tags[i];
2591         while (codec_tags->id != AV_CODEC_ID_NONE) {
2592             if (codec_tags->id == id) {
2593                 *tag = codec_tags->tag;
2594                 return 1;
2595             }
2596             codec_tags++;
2597         }
2598     }
2599     return 0;
2600 }
2601
2602 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2603 {
2604     int i;
2605     for(i=0; tags && tags[i]; i++){
2606         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2607         if(id!=AV_CODEC_ID_NONE) return id;
2608     }
2609     return AV_CODEC_ID_NONE;
2610 }
2611
2612 static void compute_chapters_end(AVFormatContext *s)
2613 {
2614     unsigned int i, j;
2615     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2616
2617     for (i = 0; i < s->nb_chapters; i++)
2618         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2619             AVChapter *ch = s->chapters[i];
2620             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2621                                      : INT64_MAX;
2622
2623             for (j = 0; j < s->nb_chapters; j++) {
2624                 AVChapter *ch1 = s->chapters[j];
2625                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2626                 if (j != i && next_start > ch->start && next_start < end)
2627                     end = next_start;
2628             }
2629             ch->end = (end == INT64_MAX) ? ch->start : end;
2630         }
2631 }
2632
2633 static int get_std_framerate(int i){
2634     if(i<60*12) return (i+1)*1001;
2635     else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2636 }
2637
2638 /*
2639  * Is the time base unreliable.
2640  * This is a heuristic to balance between quick acceptance of the values in
2641  * the headers vs. some extra checks.
2642  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2643  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2644  * And there are "variable" fps files this needs to detect as well.
2645  */
2646 static int tb_unreliable(AVCodecContext *c){
2647     if(   c->time_base.den >= 101L*c->time_base.num
2648        || c->time_base.den <    5L*c->time_base.num
2649 /*       || c->codec_tag == AV_RL32("DIVX")
2650        || c->codec_tag == AV_RL32("XVID")*/
2651        || c->codec_tag == AV_RL32("mp4v")
2652        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2653        || c->codec_id == AV_CODEC_ID_H264
2654        )
2655         return 1;
2656     return 0;
2657 }
2658
2659 #if FF_API_FORMAT_PARAMETERS
2660 int av_find_stream_info(AVFormatContext *ic)
2661 {
2662     return avformat_find_stream_info(ic, NULL);
2663 }
2664 #endif
2665
2666 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2667 {
2668     int ret;
2669
2670     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2671         avctx->extradata_size = 0;
2672         return AVERROR(EINVAL);
2673     }
2674     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2675     if (avctx->extradata) {
2676         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2677         avctx->extradata_size = size;
2678         ret = 0;
2679     } else {
2680         avctx->extradata_size = 0;
2681         ret = AVERROR(ENOMEM);
2682     }
2683     return ret;
2684 }
2685
2686 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2687 {
2688     int i, count, ret = 0, j;
2689     int64_t read_size;
2690     AVStream *st;
2691     AVPacket pkt1, *pkt;
2692     int64_t old_offset = avio_tell(ic->pb);
2693     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2694     int flush_codecs = ic->probesize > 0;
2695
2696     if(ic->pb)
2697         av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2698
2699     for(i=0;i<ic->nb_streams;i++) {
2700         const AVCodec *codec;
2701         AVDictionary *thread_opt = NULL;
2702         st = ic->streams[i];
2703
2704         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2705             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2706 /*            if(!st->time_base.num)
2707                 st->time_base= */
2708             if(!st->codec->time_base.num)
2709                 st->codec->time_base= st->time_base;
2710         }
2711         //only for the split stuff
2712         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2713             st->parser = av_parser_init(st->codec->codec_id);
2714             if(st->parser){
2715                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2716                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2717                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2718                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2719                 }
2720             } else if (st->need_parsing) {
2721                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2722                        "%s, packets or times may be invalid.\n",
2723                        avcodec_get_name(st->codec->codec_id));
2724             }
2725         }
2726         codec = find_decoder(ic, st, st->codec->codec_id);
2727
2728         /* force thread count to 1 since the h264 decoder will not extract SPS
2729          *  and PPS to extradata during multi-threaded decoding */
2730         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2731
2732         /* Ensure that subtitle_header is properly set. */
2733         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2734             && codec && !st->codec->codec)
2735             avcodec_open2(st->codec, codec, options ? &options[i]
2736                               : &thread_opt);
2737
2738         //try to just open decoders, in case this is enough to get parameters
2739         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2740             if (codec && !st->codec->codec)
2741                 avcodec_open2(st->codec, codec, options ? &options[i]
2742                               : &thread_opt);
2743         }
2744         if (!options)
2745             av_dict_free(&thread_opt);
2746     }
2747
2748     for (i=0; i<ic->nb_streams; i++) {
2749 #if FF_API_R_FRAME_RATE
2750         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2751 #endif
2752         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2753         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2754     }
2755
2756     count = 0;
2757     read_size = 0;
2758     for(;;) {
2759         if (ff_check_interrupt(&ic->interrupt_callback)){
2760             ret= AVERROR_EXIT;
2761             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2762             break;
2763         }
2764
2765         /* check if one codec still needs to be handled */
2766         for(i=0;i<ic->nb_streams;i++) {
2767             int fps_analyze_framecount = 20;
2768
2769             st = ic->streams[i];
2770             if (!has_codec_parameters(st, NULL))
2771                 break;
2772             /* if the timebase is coarse (like the usual millisecond precision
2773                of mkv), we need to analyze more frames to reliably arrive at
2774                the correct fps */
2775             if (av_q2d(st->time_base) > 0.0005)
2776                 fps_analyze_framecount *= 2;
2777             if (ic->fps_probe_size >= 0)
2778                 fps_analyze_framecount = ic->fps_probe_size;
2779             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2780                 fps_analyze_framecount = 0;
2781             /* variable fps and no guess at the real fps */
2782             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2783                && st->info->duration_count < fps_analyze_framecount
2784                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2785                 break;
2786             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2787                 break;
2788             if (st->first_dts == AV_NOPTS_VALUE &&
2789                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2790                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2791                 break;
2792         }
2793         if (i == ic->nb_streams) {
2794             /* NOTE: if the format has no header, then we need to read
2795                some packets to get most of the streams, so we cannot
2796                stop here */
2797             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2798                 /* if we found the info for all the codecs, we can stop */
2799                 ret = count;
2800                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2801                 flush_codecs = 0;
2802                 break;
2803             }
2804         }
2805         /* we did not get all the codec info, but we read too much data */
2806         if (read_size >= ic->probesize) {
2807             ret = count;
2808             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2809             for (i = 0; i < ic->nb_streams; i++)
2810                 if (!ic->streams[i]->r_frame_rate.num &&
2811                     ic->streams[i]->info->duration_count <= 1 &&
2812                     strcmp(ic->iformat->name, "image2"))
2813                     av_log(ic, AV_LOG_WARNING,
2814                            "Stream #%d: not enough frames to estimate rate; "
2815                            "consider increasing probesize\n", i);
2816             break;
2817         }
2818
2819         /* NOTE: a new stream can be added there if no header in file
2820            (AVFMTCTX_NOHEADER) */
2821         ret = read_frame_internal(ic, &pkt1);
2822         if (ret == AVERROR(EAGAIN))
2823             continue;
2824
2825         if (ret < 0) {
2826             /* EOF or error*/
2827             break;
2828         }
2829
2830         if (ic->flags & AVFMT_FLAG_NOBUFFER)
2831             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2832         {
2833             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2834                                 &ic->packet_buffer_end);
2835             if (!pkt) {
2836                 ret = AVERROR(ENOMEM);
2837                 goto find_stream_info_err;
2838             }
2839             if ((ret = av_dup_packet(pkt)) < 0)
2840                 goto find_stream_info_err;
2841         }
2842
2843         read_size += pkt->size;
2844
2845         st = ic->streams[pkt->stream_index];
2846         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2847             /* check for non-increasing dts */
2848             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2849                 st->info->fps_last_dts >= pkt->dts) {
2850                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2851                        "packet %d with DTS %"PRId64", packet %d with DTS "
2852                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2853                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2854                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2855             }
2856             /* check for a discontinuity in dts - if the difference in dts
2857              * is more than 1000 times the average packet duration in the sequence,
2858              * we treat it as a discontinuity */
2859             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2860                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2861                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2862                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2863                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2864                        "packet %d with DTS %"PRId64", packet %d with DTS "
2865                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2866                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2867                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2868             }
2869
2870             /* update stored dts values */
2871             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2872                 st->info->fps_first_dts     = pkt->dts;
2873                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2874             }
2875             st->info->fps_last_dts = pkt->dts;
2876             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2877         }
2878         if (st->codec_info_nb_frames>1) {
2879             int64_t t=0;
2880             if (st->time_base.den > 0)
2881                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2882             if (st->avg_frame_rate.num > 0)
2883                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2884
2885             if (   t==0
2886                 && st->codec_info_nb_frames>30
2887                 && st->info->fps_first_dts != AV_NOPTS_VALUE
2888                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
2889                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
2890
2891             if (t >= ic->max_analyze_duration) {
2892                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2893                 break;
2894             }
2895             if (pkt->duration) {
2896                 st->info->codec_info_duration        += pkt->duration;
2897                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2898             }
2899         }
2900 #if FF_API_R_FRAME_RATE
2901         {
2902             int64_t last = st->info->last_dts;
2903
2904             if(   pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2905                && pkt->dts - (uint64_t)last < INT64_MAX){
2906                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2907                 int64_t duration= pkt->dts - last;
2908
2909                 if (!st->info->duration_error)
2910                     st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2911                 if (!st->info->duration_error)
2912                     return AVERROR(ENOMEM);
2913
2914 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2915 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2916                 for (i=0; i<MAX_STD_TIMEBASES; i++) {
2917                     int framerate= get_std_framerate(i);
2918                     double sdts= dts*framerate/(1001*12);
2919                     for(j=0; j<2; j++){
2920                         int64_t ticks= llrint(sdts+j*0.5);
2921                         double error= sdts - ticks + j*0.5;
2922                         st->info->duration_error[j][0][i] += error;
2923                         st->info->duration_error[j][1][i] += error*error;
2924                     }
2925                 }
2926                 st->info->duration_count++;
2927                 // ignore the first 4 values, they might have some random jitter
2928                 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2929                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2930             }
2931             if (pkt->dts != AV_NOPTS_VALUE)
2932                 st->info->last_dts = pkt->dts;
2933         }
2934 #endif
2935         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2936             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2937             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2938                 if (ff_alloc_extradata(st->codec, i))
2939                     return AVERROR(ENOMEM);
2940                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2941             }
2942         }
2943
2944         /* if still no information, we try to open the codec and to
2945            decompress the frame. We try to avoid that in most cases as
2946            it takes longer and uses more memory. For MPEG-4, we need to
2947            decompress for QuickTime.
2948
2949            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2950            least one frame of codec data, this makes sure the codec initializes
2951            the channel configuration and does not only trust the values from the container.
2952         */
2953         try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2954
2955         st->codec_info_nb_frames++;
2956         count++;
2957     }
2958
2959     if (flush_codecs) {
2960         AVPacket empty_pkt = { 0 };
2961         int err = 0;
2962         av_init_packet(&empty_pkt);
2963
2964         for(i=0;i<ic->nb_streams;i++) {
2965
2966             st = ic->streams[i];
2967
2968             /* flush the decoders */
2969             if (st->info->found_decoder == 1) {
2970                 do {
2971                     err = try_decode_frame(ic, st, &empty_pkt,
2972                                             (options && i < orig_nb_streams) ?
2973                                             &options[i] : NULL);
2974                 } while (err > 0 && !has_codec_parameters(st, NULL));
2975
2976                 if (err < 0) {
2977                     av_log(ic, AV_LOG_INFO,
2978                         "decoding for stream %d failed\n", st->index);
2979                 }
2980             }
2981         }
2982     }
2983
2984     // close codecs which were opened in try_decode_frame()
2985     for(i=0;i<ic->nb_streams;i++) {
2986         st = ic->streams[i];
2987         avcodec_close(st->codec);
2988     }
2989     for(i=0;i<ic->nb_streams;i++) {
2990         st = ic->streams[i];
2991         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2992             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2993                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2994                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2995                     st->codec->codec_tag= tag;
2996             }
2997
2998             /* estimate average framerate if not set by demuxer */
2999             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3000                 int      best_fps = 0;
3001                 double best_error = 0.01;
3002
3003                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3004                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3005                     st->info->codec_info_duration        < 0)
3006                     continue;
3007                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3008                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3009                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3010
3011                 /* round guessed framerate to a "standard" framerate if it's
3012                  * within 1% of the original estimate*/
3013                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3014                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
3015                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3016
3017                     if (error < best_error) {
3018                         best_error = error;
3019                         best_fps   = std_fps.num;
3020                     }
3021                 }
3022                 if (best_fps) {
3023                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3024                               best_fps, 12*1001, INT_MAX);
3025                 }
3026             }
3027             // the check for tb_unreliable() is not completely correct, since this is not about handling
3028             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3029             // ipmovie.c produces.
3030             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)
3031                 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);
3032             if (st->info->duration_count>1 && !st->r_frame_rate.num
3033                 && tb_unreliable(st->codec)) {
3034                 int num = 0;
3035                 double best_error= 0.01;
3036
3037                 for (j=0; j<MAX_STD_TIMEBASES; j++) {
3038                     int k;
3039
3040                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3041                         continue;
3042                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3043                         continue;
3044                     for(k=0; k<2; k++){
3045                         int n= st->info->duration_count;
3046                         double a= st->info->duration_error[k][0][j] / n;
3047                         double error= st->info->duration_error[k][1][j]/n - a*a;
3048
3049                         if(error < best_error && best_error> 0.000000001){
3050                             best_error= error;
3051                             num = get_std_framerate(j);
3052                         }
3053                         if(error < 0.02)
3054                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3055                     }
3056                 }
3057                 // do not increase frame rate by more than 1 % in order to match a standard rate.
3058                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3059                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3060             }
3061
3062             if (!st->r_frame_rate.num){
3063                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3064                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3065                     st->r_frame_rate.num = st->codec->time_base.den;
3066                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3067                 }else{
3068                     st->r_frame_rate.num = st->time_base.den;
3069                     st->r_frame_rate.den = st->time_base.num;
3070                 }
3071             }
3072         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3073             if(!st->codec->bits_per_coded_sample)
3074                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3075             // set stream disposition based on audio service type
3076             switch (st->codec->audio_service_type) {
3077             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3078                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3079             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3080                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3081             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3082                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3083             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3084                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3085             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3086                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3087             }
3088         }
3089     }
3090
3091     if(ic->probesize)
3092     estimate_timings(ic, old_offset);
3093
3094     if (ret >= 0 && ic->nb_streams)
3095         ret = -1; /* we could not have all the codec parameters before EOF */
3096     for(i=0;i<ic->nb_streams;i++) {
3097         const char *errmsg;
3098         st = ic->streams[i];
3099         if (!has_codec_parameters(st, &errmsg)) {
3100             char buf[256];
3101             avcodec_string(buf, sizeof(buf), st->codec, 0);
3102             av_log(ic, AV_LOG_WARNING,
3103                    "Could not find codec parameters for stream %d (%s): %s\n"
3104                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3105                    i, buf, errmsg);
3106         } else {
3107             ret = 0;
3108         }
3109     }
3110
3111     compute_chapters_end(ic);
3112
3113  find_stream_info_err:
3114     for (i=0; i < ic->nb_streams; i++) {
3115         st = ic->streams[i];
3116         if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3117             ic->streams[i]->codec->thread_count = 0;
3118         if (st->info)
3119             av_freep(&st->info->duration_error);
3120         av_freep(&ic->streams[i]->info);
3121     }
3122     if(ic->pb)
3123         av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3124     return ret;
3125 }
3126
3127 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3128 {
3129     int i, j;
3130
3131     for (i = 0; i < ic->nb_programs; i++) {
3132         if (ic->programs[i] == last) {
3133             last = NULL;
3134         } else {
3135             if (!last)
3136                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3137                     if (ic->programs[i]->stream_index[j] == s)
3138                         return ic->programs[i];
3139         }
3140     }
3141     return NULL;
3142 }
3143
3144 int av_find_best_stream(AVFormatContext *ic,
3145                         enum AVMediaType type,
3146                         int wanted_stream_nb,
3147                         int related_stream,
3148                         AVCodec **decoder_ret,
3149                         int flags)
3150 {
3151     int i, nb_streams = ic->nb_streams;
3152     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3153     unsigned *program = NULL;
3154     AVCodec *decoder = NULL, *best_decoder = NULL;
3155
3156     if (related_stream >= 0 && wanted_stream_nb < 0) {
3157         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3158         if (p) {
3159             program = p->stream_index;
3160             nb_streams = p->nb_stream_indexes;
3161         }
3162     }
3163     for (i = 0; i < nb_streams; i++) {
3164         int real_stream_index = program ? program[i] : i;
3165         AVStream *st = ic->streams[real_stream_index];
3166         AVCodecContext *avctx = st->codec;
3167         if (avctx->codec_type != type)
3168             continue;
3169         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3170             continue;
3171         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3172             continue;
3173         if (decoder_ret) {
3174             decoder = find_decoder(ic, st, st->codec->codec_id);
3175             if (!decoder) {
3176                 if (ret < 0)
3177                     ret = AVERROR_DECODER_NOT_FOUND;
3178                 continue;
3179             }
3180         }
3181         count = st->codec_info_nb_frames;
3182         bitrate = avctx->bit_rate;
3183         multiframe = FFMIN(5, count);
3184         if ((best_multiframe >  multiframe) ||
3185             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3186             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3187             continue;
3188         best_count = count;
3189         best_bitrate = bitrate;
3190         best_multiframe = multiframe;
3191         ret = real_stream_index;
3192         best_decoder = decoder;
3193         if (program && i == nb_streams - 1 && ret < 0) {
3194             program = NULL;
3195             nb_streams = ic->nb_streams;
3196             i = 0; /* no related stream found, try again with everything */
3197         }
3198     }
3199     if (decoder_ret)
3200         *decoder_ret = best_decoder;
3201     return ret;
3202 }
3203
3204 /*******************************************************/
3205
3206 int av_read_play(AVFormatContext *s)
3207 {
3208     if (s->iformat->read_play)
3209         return s->iformat->read_play(s);
3210     if (s->pb)
3211         return avio_pause(s->pb, 0);
3212     return AVERROR(ENOSYS);
3213 }
3214
3215 int av_read_pause(AVFormatContext *s)
3216 {
3217     if (s->iformat->read_pause)
3218         return s->iformat->read_pause(s);
3219     if (s->pb)
3220         return avio_pause(s->pb, 1);
3221     return AVERROR(ENOSYS);
3222 }
3223
3224 void ff_free_stream(AVFormatContext *s, AVStream *st){
3225     av_assert0(s->nb_streams>0);
3226     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3227
3228     if (st->parser) {
3229         av_parser_close(st->parser);
3230     }
3231     if (st->attached_pic.data)
3232         av_free_packet(&st->attached_pic);
3233     av_dict_free(&st->metadata);
3234     av_freep(&st->probe_data.buf);
3235     av_freep(&st->index_entries);
3236     av_freep(&st->codec->extradata);
3237     av_freep(&st->codec->subtitle_header);
3238     av_freep(&st->codec);
3239     av_freep(&st->priv_data);
3240     if (st->info)
3241         av_freep(&st->info->duration_error);
3242     av_freep(&st->info);
3243     av_freep(&s->streams[ --s->nb_streams ]);
3244 }
3245
3246 void avformat_free_context(AVFormatContext *s)
3247 {
3248     int i;
3249
3250     if (!s)
3251         return;
3252
3253     av_opt_free(s);
3254     if (s->iformat && s->iformat->priv_class && s->priv_data)
3255         av_opt_free(s->priv_data);
3256
3257     for(i=s->nb_streams-1; i>=0; i--) {
3258         ff_free_stream(s, s->streams[i]);
3259     }
3260     for(i=s->nb_programs-1; i>=0; i--) {
3261         av_dict_free(&s->programs[i]->metadata);
3262         av_freep(&s->programs[i]->stream_index);
3263         av_freep(&s->programs[i]);
3264     }
3265     av_freep(&s->programs);
3266     av_freep(&s->priv_data);
3267     while(s->nb_chapters--) {
3268         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3269         av_freep(&s->chapters[s->nb_chapters]);
3270     }
3271     av_freep(&s->chapters);
3272     av_dict_free(&s->metadata);
3273     av_freep(&s->streams);
3274     av_free(s);
3275 }
3276
3277 #if FF_API_CLOSE_INPUT_FILE
3278 void av_close_input_file(AVFormatContext *s)
3279 {
3280     avformat_close_input(&s);
3281 }
3282 #endif
3283
3284 void avformat_close_input(AVFormatContext **ps)
3285 {
3286     AVFormatContext *s;
3287     AVIOContext *pb;
3288
3289     if (!ps || !*ps)
3290         return;
3291
3292     s = *ps;
3293     pb = s->pb;
3294
3295     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3296         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3297         pb = NULL;
3298
3299     flush_packet_queue(s);
3300
3301     if (s->iformat) {
3302         if (s->iformat->read_close)
3303             s->iformat->read_close(s);
3304     }
3305
3306     avformat_free_context(s);
3307
3308     *ps = NULL;
3309
3310     avio_close(pb);
3311 }
3312
3313 #if FF_API_NEW_STREAM
3314 AVStream *av_new_stream(AVFormatContext *s, int id)
3315 {
3316     AVStream *st = avformat_new_stream(s, NULL);
3317     if (st)
3318         st->id = id;
3319     return st;
3320 }
3321 #endif
3322
3323 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3324 {
3325     AVStream *st;
3326     int i;
3327     AVStream **streams;
3328
3329     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3330         return NULL;
3331     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3332     if (!streams)
3333         return NULL;
3334     s->streams = streams;
3335
3336     st = av_mallocz(sizeof(AVStream));
3337     if (!st)
3338         return NULL;
3339     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3340         av_free(st);
3341         return NULL;
3342     }
3343     st->info->last_dts = AV_NOPTS_VALUE;
3344
3345     st->codec = avcodec_alloc_context3(c);
3346     if (s->iformat) {
3347         /* no default bitrate if decoding */
3348         st->codec->bit_rate = 0;
3349     }
3350     st->index = s->nb_streams;
3351     st->start_time = AV_NOPTS_VALUE;
3352     st->duration = AV_NOPTS_VALUE;
3353         /* we set the current DTS to 0 so that formats without any timestamps
3354            but durations get some timestamps, formats with some unknown
3355            timestamps have their first few packets buffered and the
3356            timestamps corrected before they are returned to the user */
3357     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3358     st->first_dts = AV_NOPTS_VALUE;
3359     st->probe_packets = MAX_PROBE_PACKETS;
3360     st->pts_wrap_reference = AV_NOPTS_VALUE;
3361     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3362
3363     /* default pts setting is MPEG-like */
3364     avpriv_set_pts_info(st, 33, 1, 90000);
3365     st->last_IP_pts = AV_NOPTS_VALUE;
3366     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3367         st->pts_buffer[i]= AV_NOPTS_VALUE;
3368
3369     st->sample_aspect_ratio = (AVRational){0,1};
3370
3371 #if FF_API_R_FRAME_RATE
3372     st->info->last_dts      = AV_NOPTS_VALUE;
3373 #endif
3374     st->info->fps_first_dts = AV_NOPTS_VALUE;
3375     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3376
3377     s->streams[s->nb_streams++] = st;
3378     return st;
3379 }
3380
3381 AVProgram *av_new_program(AVFormatContext *ac, int id)
3382 {
3383     AVProgram *program=NULL;
3384     int i;
3385
3386     av_dlog(ac, "new_program: id=0x%04x\n", id);
3387
3388     for(i=0; i<ac->nb_programs; i++)
3389         if(ac->programs[i]->id == id)
3390             program = ac->programs[i];
3391
3392     if(!program){
3393         program = av_mallocz(sizeof(AVProgram));
3394         if (!program)
3395             return NULL;
3396         dynarray_add(&ac->programs, &ac->nb_programs, program);
3397         program->discard = AVDISCARD_NONE;
3398     }
3399     program->id = id;
3400     program->pts_wrap_reference = AV_NOPTS_VALUE;
3401     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3402
3403     program->start_time =
3404     program->end_time   = AV_NOPTS_VALUE;
3405
3406     return program;
3407 }
3408
3409 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3410 {
3411     AVChapter *chapter = NULL;
3412     int i;
3413
3414     for(i=0; i<s->nb_chapters; i++)
3415         if(s->chapters[i]->id == id)
3416             chapter = s->chapters[i];
3417
3418     if(!chapter){
3419         chapter= av_mallocz(sizeof(AVChapter));
3420         if(!chapter)
3421             return NULL;
3422         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3423     }
3424     av_dict_set(&chapter->metadata, "title", title, 0);
3425     chapter->id    = id;
3426     chapter->time_base= time_base;
3427     chapter->start = start;
3428     chapter->end   = end;
3429
3430     return chapter;
3431 }
3432
3433 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3434 {
3435     int i, j;
3436     AVProgram *program=NULL;
3437     void *tmp;
3438
3439     if (idx >= ac->nb_streams) {
3440         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3441         return;
3442     }
3443
3444     for(i=0; i<ac->nb_programs; i++){
3445         if(ac->programs[i]->id != progid)
3446             continue;
3447         program = ac->programs[i];
3448         for(j=0; j<program->nb_stream_indexes; j++)
3449             if(program->stream_index[j] == idx)
3450                 return;
3451
3452         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3453         if(!tmp)
3454             return;
3455         program->stream_index = tmp;
3456         program->stream_index[program->nb_stream_indexes++] = idx;
3457         return;
3458     }
3459 }
3460
3461 static void print_fps(double d, const char *postfix){
3462     uint64_t v= lrintf(d*100);
3463     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3464     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3465     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3466 }
3467
3468 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3469 {
3470     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3471         AVDictionaryEntry *tag=NULL;
3472
3473         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3474         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3475             if(strcmp("language", tag->key)){
3476                 const char *p = tag->value;
3477                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3478                 while(*p) {
3479                     char tmp[256];
3480                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3481                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3482                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3483                     p += len;
3484                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3485                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3486                     if (*p) p++;
3487                 }
3488                 av_log(ctx, AV_LOG_INFO, "\n");
3489             }
3490         }
3491     }
3492 }
3493
3494 /* "user interface" functions */
3495 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3496 {
3497     char buf[256];
3498     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3499     AVStream *st = ic->streams[i];
3500     int g = av_gcd(st->time_base.num, st->time_base.den);
3501     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3502     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3503     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3504     /* the pid is an important information, so we display it */
3505     /* XXX: add a generic system */
3506     if (flags & AVFMT_SHOW_IDS)
3507         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3508     if (lang)
3509         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3510     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3511     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3512     if (st->sample_aspect_ratio.num && // default
3513         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3514         AVRational display_aspect_ratio;
3515         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3516                   st->codec->width*st->sample_aspect_ratio.num,
3517                   st->codec->height*st->sample_aspect_ratio.den,
3518                   1024*1024);
3519         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3520                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3521                  display_aspect_ratio.num, display_aspect_ratio.den);
3522     }
3523     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3524         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3525             print_fps(av_q2d(st->avg_frame_rate), "fps");
3526 #if FF_API_R_FRAME_RATE
3527         if(st->r_frame_rate.den && st->r_frame_rate.num)
3528             print_fps(av_q2d(st->r_frame_rate), "tbr");
3529 #endif
3530         if(st->time_base.den && st->time_base.num)
3531             print_fps(1/av_q2d(st->time_base), "tbn");
3532         if(st->codec->time_base.den && st->codec->time_base.num)
3533             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3534     }
3535     if (st->disposition & AV_DISPOSITION_DEFAULT)
3536         av_log(NULL, AV_LOG_INFO, " (default)");
3537     if (st->disposition & AV_DISPOSITION_DUB)
3538         av_log(NULL, AV_LOG_INFO, " (dub)");
3539     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3540         av_log(NULL, AV_LOG_INFO, " (original)");
3541     if (st->disposition & AV_DISPOSITION_COMMENT)
3542         av_log(NULL, AV_LOG_INFO, " (comment)");
3543     if (st->disposition & AV_DISPOSITION_LYRICS)
3544         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3545     if (st->disposition & AV_DISPOSITION_KARAOKE)
3546         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3547     if (st->disposition & AV_DISPOSITION_FORCED)
3548         av_log(NULL, AV_LOG_INFO, " (forced)");
3549     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3550         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3551     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3552         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3553     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3554         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3555     av_log(NULL, AV_LOG_INFO, "\n");
3556     dump_metadata(NULL, st->metadata, "    ");
3557 }
3558
3559 void av_dump_format(AVFormatContext *ic,
3560                     int index,
3561                     const char *url,
3562                     int is_output)
3563 {
3564     int i;
3565     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3566     if (ic->nb_streams && !printed)
3567         return;
3568
3569     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3570             is_output ? "Output" : "Input",
3571             index,
3572             is_output ? ic->oformat->name : ic->iformat->name,
3573             is_output ? "to" : "from", url);
3574     dump_metadata(NULL, ic->metadata, "  ");
3575     if (!is_output) {
3576         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3577         if (ic->duration != AV_NOPTS_VALUE) {
3578             int hours, mins, secs, us;
3579             int64_t duration = ic->duration + 5000;
3580             secs = duration / AV_TIME_BASE;
3581             us = duration % AV_TIME_BASE;
3582             mins = secs / 60;
3583             secs %= 60;
3584             hours = mins / 60;
3585             mins %= 60;
3586             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3587                    (100 * us) / AV_TIME_BASE);
3588         } else {
3589             av_log(NULL, AV_LOG_INFO, "N/A");
3590         }
3591         if (ic->start_time != AV_NOPTS_VALUE) {
3592             int secs, us;
3593             av_log(NULL, AV_LOG_INFO, ", start: ");
3594             secs = ic->start_time / AV_TIME_BASE;
3595             us = abs(ic->start_time % AV_TIME_BASE);
3596             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3597                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3598         }
3599         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3600         if (ic->bit_rate) {
3601             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3602         } else {
3603             av_log(NULL, AV_LOG_INFO, "N/A");
3604         }
3605         av_log(NULL, AV_LOG_INFO, "\n");
3606     }
3607     for (i = 0; i < ic->nb_chapters; i++) {
3608         AVChapter *ch = ic->chapters[i];
3609         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3610         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3611         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3612
3613         dump_metadata(NULL, ch->metadata, "    ");
3614     }
3615     if(ic->nb_programs) {
3616         int j, k, total = 0;
3617         for(j=0; j<ic->nb_programs; j++) {
3618             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3619                                                   "name", NULL, 0);
3620             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3621                    name ? name->value : "");
3622             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3623             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3624                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3625                 printed[ic->programs[j]->stream_index[k]] = 1;
3626             }
3627             total += ic->programs[j]->nb_stream_indexes;
3628         }
3629         if (total < ic->nb_streams)
3630             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3631     }
3632     for(i=0;i<ic->nb_streams;i++)
3633         if (!printed[i])
3634             dump_stream_format(ic, i, index, is_output);
3635
3636     av_free(printed);
3637 }
3638
3639 uint64_t ff_ntp_time(void)
3640 {
3641   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3642 }
3643
3644 int av_get_frame_filename(char *buf, int buf_size,
3645                           const char *path, int number)
3646 {
3647     const char *p;
3648     char *q, buf1[20], c;
3649     int nd, len, percentd_found;
3650
3651     q = buf;
3652     p = path;
3653     percentd_found = 0;
3654     for(;;) {
3655         c = *p++;
3656         if (c == '\0')
3657             break;
3658         if (c == '%') {
3659             do {
3660                 nd = 0;
3661                 while (av_isdigit(*p)) {
3662                     nd = nd * 10 + *p++ - '0';
3663                 }
3664                 c = *p++;
3665             } while (av_isdigit(c));
3666
3667             switch(c) {
3668             case '%':
3669                 goto addchar;
3670             case 'd':
3671                 if (percentd_found)
3672                     goto fail;
3673                 percentd_found = 1;
3674                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3675                 len = strlen(buf1);
3676                 if ((q - buf + len) > buf_size - 1)
3677                     goto fail;
3678                 memcpy(q, buf1, len);
3679                 q += len;
3680                 break;
3681             default:
3682                 goto fail;
3683             }
3684         } else {
3685         addchar:
3686             if ((q - buf) < buf_size - 1)
3687                 *q++ = c;
3688         }
3689     }
3690     if (!percentd_found)
3691         goto fail;
3692     *q = '\0';
3693     return 0;
3694  fail:
3695     *q = '\0';
3696     return -1;
3697 }
3698
3699 static void hex_dump_internal(void *avcl, FILE *f, int level,
3700                               const uint8_t *buf, int size)
3701 {
3702     int len, i, j, c;
3703 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3704
3705     for(i=0;i<size;i+=16) {
3706         len = size - i;
3707         if (len > 16)
3708             len = 16;
3709         PRINT("%08x ", i);
3710         for(j=0;j<16;j++) {
3711             if (j < len)
3712                 PRINT(" %02x", buf[i+j]);
3713             else
3714                 PRINT("   ");
3715         }
3716         PRINT(" ");
3717         for(j=0;j<len;j++) {
3718             c = buf[i+j];
3719             if (c < ' ' || c > '~')
3720                 c = '.';
3721             PRINT("%c", c);
3722         }
3723         PRINT("\n");
3724     }
3725 #undef PRINT
3726 }
3727
3728 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3729 {
3730     hex_dump_internal(NULL, f, 0, buf, size);
3731 }
3732
3733 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3734 {
3735     hex_dump_internal(avcl, NULL, level, buf, size);
3736 }
3737
3738 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3739 {
3740 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3741     PRINT("stream #%d:\n", pkt->stream_index);
3742     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3743     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3744     /* DTS is _always_ valid after av_read_frame() */
3745     PRINT("  dts=");
3746     if (pkt->dts == AV_NOPTS_VALUE)
3747         PRINT("N/A");
3748     else
3749         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3750     /* PTS may not be known if B-frames are present. */
3751     PRINT("  pts=");
3752     if (pkt->pts == AV_NOPTS_VALUE)
3753         PRINT("N/A");
3754     else
3755         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3756     PRINT("\n");
3757     PRINT("  size=%d\n", pkt->size);
3758 #undef PRINT
3759     if (dump_payload)
3760         av_hex_dump(f, pkt->data, pkt->size);
3761 }
3762
3763 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3764 {
3765     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3766 }
3767
3768 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3769                       AVStream *st)
3770 {
3771     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3772 }
3773
3774 void av_url_split(char *proto, int proto_size,
3775                   char *authorization, int authorization_size,
3776                   char *hostname, int hostname_size,
3777                   int *port_ptr,
3778                   char *path, int path_size,
3779                   const char *url)
3780 {
3781     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3782
3783     if (port_ptr)               *port_ptr = -1;
3784     if (proto_size > 0)         proto[0] = 0;
3785     if (authorization_size > 0) authorization[0] = 0;
3786     if (hostname_size > 0)      hostname[0] = 0;
3787     if (path_size > 0)          path[0] = 0;
3788
3789     /* parse protocol */
3790     if ((p = strchr(url, ':'))) {
3791         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3792         p++; /* skip ':' */
3793         if (*p == '/') p++;
3794         if (*p == '/') p++;
3795     } else {
3796         /* no protocol means plain filename */
3797         av_strlcpy(path, url, path_size);
3798         return;
3799     }
3800
3801     /* separate path from hostname */
3802     ls = strchr(p, '/');
3803     ls2 = strchr(p, '?');
3804     if(!ls)
3805         ls = ls2;
3806     else if (ls && ls2)
3807         ls = FFMIN(ls, ls2);
3808     if(ls)
3809         av_strlcpy(path, ls, path_size);
3810     else
3811         ls = &p[strlen(p)]; // XXX
3812
3813     /* the rest is hostname, use that to parse auth/port */
3814     if (ls != p) {
3815         /* authorization (user[:pass]@hostname) */
3816         at2 = p;
3817         while ((at = strchr(p, '@')) && at < ls) {
3818             av_strlcpy(authorization, at2,
3819                        FFMIN(authorization_size, at + 1 - at2));
3820             p = at + 1; /* skip '@' */
3821         }
3822
3823         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3824             /* [host]:port */
3825             av_strlcpy(hostname, p + 1,
3826                        FFMIN(hostname_size, brk - p));
3827             if (brk[1] == ':' && port_ptr)
3828                 *port_ptr = atoi(brk + 2);
3829         } else if ((col = strchr(p, ':')) && col < ls) {
3830             av_strlcpy(hostname, p,
3831                        FFMIN(col + 1 - p, hostname_size));
3832             if (port_ptr) *port_ptr = atoi(col + 1);
3833         } else
3834             av_strlcpy(hostname, p,
3835                        FFMIN(ls + 1 - p, hostname_size));
3836     }
3837 }
3838
3839 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3840 {
3841     int i;
3842     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3843                                            '4', '5', '6', '7',
3844                                            '8', '9', 'A', 'B',
3845                                            'C', 'D', 'E', 'F' };
3846     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3847                                            '4', '5', '6', '7',
3848                                            '8', '9', 'a', 'b',
3849                                            'c', 'd', 'e', 'f' };
3850     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3851
3852     for(i = 0; i < s; i++) {
3853         buff[i * 2]     = hex_table[src[i] >> 4];
3854         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3855     }
3856
3857     return buff;
3858 }
3859
3860 int ff_hex_to_data(uint8_t *data, const char *p)
3861 {
3862     int c, len, v;
3863
3864     len = 0;
3865     v = 1;
3866     for (;;) {
3867         p += strspn(p, SPACE_CHARS);
3868         if (*p == '\0')
3869             break;
3870         c = av_toupper((unsigned char) *p++);
3871         if (c >= '0' && c <= '9')
3872             c = c - '0';
3873         else if (c >= 'A' && c <= 'F')
3874             c = c - 'A' + 10;
3875         else
3876             break;
3877         v = (v << 4) | c;
3878         if (v & 0x100) {
3879             if (data)
3880                 data[len] = v;
3881             len++;
3882             v = 1;
3883         }
3884     }
3885     return len;
3886 }
3887
3888 #if FF_API_SET_PTS_INFO
3889 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3890                      unsigned int pts_num, unsigned int pts_den)
3891 {
3892     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3893 }
3894 #endif
3895
3896 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3897                          unsigned int pts_num, unsigned int pts_den)
3898 {
3899     AVRational new_tb;
3900     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3901         if(new_tb.num != pts_num)
3902             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3903     }else
3904         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3905
3906     if(new_tb.num <= 0 || new_tb.den <= 0) {
3907         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);
3908         return;
3909     }
3910     s->time_base = new_tb;
3911     av_codec_set_pkt_timebase(s->codec, new_tb);
3912     s->pts_wrap_bits = pts_wrap_bits;
3913 }
3914
3915 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3916                         void *context)
3917 {
3918     const char *ptr = str;
3919
3920     /* Parse key=value pairs. */
3921     for (;;) {
3922         const char *key;
3923         char *dest = NULL, *dest_end;
3924         int key_len, dest_len = 0;
3925
3926         /* Skip whitespace and potential commas. */
3927         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3928             ptr++;
3929         if (!*ptr)
3930             break;
3931
3932         key = ptr;
3933
3934         if (!(ptr = strchr(key, '=')))
3935             break;
3936         ptr++;
3937         key_len = ptr - key;
3938
3939         callback_get_buf(context, key, key_len, &dest, &dest_len);
3940         dest_end = dest + dest_len - 1;
3941
3942         if (*ptr == '\"') {
3943             ptr++;
3944             while (*ptr && *ptr != '\"') {
3945                 if (*ptr == '\\') {
3946                     if (!ptr[1])
3947                         break;
3948                     if (dest && dest < dest_end)
3949                         *dest++ = ptr[1];
3950                     ptr += 2;
3951                 } else {
3952                     if (dest && dest < dest_end)
3953                         *dest++ = *ptr;
3954                     ptr++;
3955                 }
3956             }
3957             if (*ptr == '\"')
3958                 ptr++;
3959         } else {
3960             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3961                 if (dest && dest < dest_end)
3962                     *dest++ = *ptr;
3963         }
3964         if (dest)
3965             *dest = 0;
3966     }
3967 }
3968
3969 int ff_find_stream_index(AVFormatContext *s, int id)
3970 {
3971     int i;
3972     for (i = 0; i < s->nb_streams; i++) {
3973         if (s->streams[i]->id == id)
3974             return i;
3975     }
3976     return -1;
3977 }
3978
3979 int64_t ff_iso8601_to_unix_time(const char *datestr)
3980 {
3981     struct tm time1 = {0}, time2 = {0};
3982     char *ret1, *ret2;
3983     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
3984     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
3985     if (ret2 && !ret1)
3986         return av_timegm(&time2);
3987     else
3988         return av_timegm(&time1);
3989 }
3990
3991 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
3992 {
3993     if (ofmt) {
3994         if (ofmt->query_codec)
3995             return ofmt->query_codec(codec_id, std_compliance);
3996         else if (ofmt->codec_tag)
3997             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3998         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
3999                  codec_id == ofmt->subtitle_codec)
4000             return 1;
4001     }
4002     return AVERROR_PATCHWELCOME;
4003 }
4004
4005 int avformat_network_init(void)
4006 {
4007 #if CONFIG_NETWORK
4008     int ret;
4009     ff_network_inited_globally = 1;
4010     if ((ret = ff_network_init()) < 0)
4011         return ret;
4012     ff_tls_init();
4013 #endif
4014     return 0;
4015 }
4016
4017 int avformat_network_deinit(void)
4018 {
4019 #if CONFIG_NETWORK
4020     ff_network_close();
4021     ff_tls_deinit();
4022 #endif
4023     return 0;
4024 }
4025
4026 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4027                         uint64_t channel_layout, int32_t sample_rate,
4028                         int32_t width, int32_t height)
4029 {
4030     uint32_t flags = 0;
4031     int size = 4;
4032     uint8_t *data;
4033     if (!pkt)
4034         return AVERROR(EINVAL);
4035     if (channels) {
4036         size += 4;
4037         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4038     }
4039     if (channel_layout) {
4040         size += 8;
4041         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4042     }
4043     if (sample_rate) {
4044         size += 4;
4045         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4046     }
4047     if (width || height) {
4048         size += 8;
4049         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4050     }
4051     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4052     if (!data)
4053         return AVERROR(ENOMEM);
4054     bytestream_put_le32(&data, flags);
4055     if (channels)
4056         bytestream_put_le32(&data, channels);
4057     if (channel_layout)
4058         bytestream_put_le64(&data, channel_layout);
4059     if (sample_rate)
4060         bytestream_put_le32(&data, sample_rate);
4061     if (width || height) {
4062         bytestream_put_le32(&data, width);
4063         bytestream_put_le32(&data, height);
4064     }
4065     return 0;
4066 }
4067
4068 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4069 {
4070     AVRational undef = {0, 1};
4071     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4072     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4073     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4074
4075     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4076                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4077     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4078         stream_sample_aspect_ratio = undef;
4079
4080     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4081                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4082     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4083         frame_sample_aspect_ratio = undef;
4084
4085     if (stream_sample_aspect_ratio.num)
4086         return stream_sample_aspect_ratio;
4087     else
4088         return frame_sample_aspect_ratio;
4089 }
4090
4091 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4092 {
4093     AVRational fr = st->r_frame_rate;
4094
4095     if (st->codec->ticks_per_frame > 1) {
4096         AVRational codec_fr = av_inv_q(st->codec->time_base);
4097         AVRational   avg_fr = st->avg_frame_rate;
4098         codec_fr.den *= st->codec->ticks_per_frame;
4099         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4100             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4101             fr = codec_fr;
4102     }
4103
4104     return fr;
4105 }
4106
4107 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4108                                     const char *spec)
4109 {
4110     if (*spec <= '9' && *spec >= '0') /* opt:index */
4111         return strtol(spec, NULL, 0) == st->index;
4112     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4113              *spec == 't') { /* opt:[vasdt] */
4114         enum AVMediaType type;
4115
4116         switch (*spec++) {
4117         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4118         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4119         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4120         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4121         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4122         default:  av_assert0(0);
4123         }
4124         if (type != st->codec->codec_type)
4125             return 0;
4126         if (*spec++ == ':') { /* possibly followed by :index */
4127             int i, index = strtol(spec, NULL, 0);
4128             for (i = 0; i < s->nb_streams; i++)
4129                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4130                    return i == st->index;
4131             return 0;
4132         }
4133         return 1;
4134     } else if (*spec == 'p' && *(spec + 1) == ':') {
4135         int prog_id, i, j;
4136         char *endptr;
4137         spec += 2;
4138         prog_id = strtol(spec, &endptr, 0);
4139         for (i = 0; i < s->nb_programs; i++) {
4140             if (s->programs[i]->id != prog_id)
4141                 continue;
4142
4143             if (*endptr++ == ':') {
4144                 int stream_idx = strtol(endptr, NULL, 0);
4145                 return stream_idx >= 0 &&
4146                     stream_idx < s->programs[i]->nb_stream_indexes &&
4147                     st->index == s->programs[i]->stream_index[stream_idx];
4148             }
4149
4150             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4151                 if (st->index == s->programs[i]->stream_index[j])
4152                     return 1;
4153         }
4154         return 0;
4155     } else if (*spec == '#') {
4156         int sid;
4157         char *endptr;
4158         sid = strtol(spec + 1, &endptr, 0);
4159         if (!*endptr)
4160             return st->id == sid;
4161     } else if (!*spec) /* empty specifier, matches everything */
4162         return 1;
4163
4164     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4165     return AVERROR(EINVAL);
4166 }
4167
4168 void ff_generate_avci_extradata(AVStream *st)
4169 {
4170     static const uint8_t avci100_1080p_extradata[] = {
4171         // SPS
4172         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4173         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4174         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4175         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4176         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4177         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4178         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4179         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4180         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4181         // PPS
4182         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4183         0xd0
4184     };
4185     static const uint8_t avci100_1080i_extradata[] = {
4186         // SPS
4187         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4188         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4189         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4190         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4191         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4192         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4193         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4194         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4195         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4196         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4197         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4198         // PPS
4199         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4200         0xd0
4201     };
4202     static const uint8_t avci50_1080i_extradata[] = {
4203         // SPS
4204         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4205         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4206         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4207         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4208         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4209         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4210         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4211         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4212         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4213         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4214         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4215         // PPS
4216         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4217         0x11
4218     };
4219     static const uint8_t avci100_720p_extradata[] = {
4220         // SPS
4221         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4222         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4223         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4224         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4225         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4226         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4227         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4228         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4229         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4230         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4231         // PPS
4232         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4233         0x11
4234     };
4235     int size = 0;
4236     const uint8_t *data = 0;
4237     if (st->codec->width == 1920) {
4238         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4239             data = avci100_1080p_extradata;
4240             size = sizeof(avci100_1080p_extradata);
4241         } else {
4242             data = avci100_1080i_extradata;
4243             size = sizeof(avci100_1080i_extradata);
4244         }
4245     } else if (st->codec->width == 1440) {
4246         data = avci50_1080i_extradata;
4247         size = sizeof(avci50_1080i_extradata);
4248     } else if (st->codec->width == 1280) {
4249         data = avci100_720p_extradata;
4250         size = sizeof(avci100_720p_extradata);
4251     }
4252     if (!size)
4253         return;
4254     av_freep(&st->codec->extradata);
4255     if (ff_alloc_extradata(st->codec, size))
4256         return;
4257     memcpy(st->codec->extradata, data, size);
4258 }