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

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