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