libavformat/utils.c

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