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