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