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

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