git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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