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