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 <stdarg.h>
  23 #include <stdint.h>
  24
  25 #include "config.h"
  26
  27 #include "libavutil/avassert.h"
  28 #include "libavutil/avstring.h"
  29 #include "libavutil/dict.h"
  30 #include "libavutil/internal.h"
  31 #include "libavutil/mathematics.h"
  32 #include "libavutil/opt.h"
  33 #include "libavutil/parseutils.h"
  34 #include "libavutil/pixdesc.h"
  35 #include "libavutil/thread.h"
  36 #include "libavutil/time.h"
  37 #include "libavutil/time_internal.h"
  38 #include "libavutil/timestamp.h"
  39
  40 #include "libavcodec/bytestream.h"
  41 #include "libavcodec/internal.h"
  42 #include "libavcodec/raw.h"
  43
  44 #include "audiointerleave.h"
  45 #include "avformat.h"
  46 #include "avio_internal.h"
  47 #include "id3v2.h"
  48 #include "internal.h"
  49 #include "metadata.h"
  50 #if CONFIG_NETWORK
  51 #include "network.h"
  52 #endif
  53 #include "riff.h"
  54 #include "url.h"
  55
  56 #include "libavutil/ffversion.h"
  57 const char av_format_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
  58
  59 static AVMutex avformat_mutex = AV_MUTEX_INITIALIZER;
  60
  61 /**
  62  * @file
  63  * various utility functions for use within FFmpeg
  64  */
  65
  66 unsigned avformat_version(void)
  67 {
  68     av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
  69     return LIBAVFORMAT_VERSION_INT;
  70 }
  71
  72 const char *avformat_configuration(void)
  73 {
  74     return FFMPEG_CONFIGURATION;
  75 }
  76
  77 const char *avformat_license(void)
  78 {
  79 #define LICENSE_PREFIX "libavformat license: "
  80     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  81 }
  82
  83 int ff_lock_avformat(void)
  84 {
  85     return ff_mutex_lock(&avformat_mutex) ? -1 : 0;
  86 }
  87
  88 int ff_unlock_avformat(void)
  89 {
  90     return ff_mutex_unlock(&avformat_mutex) ? -1 : 0;
  91 }
  92
  93 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
  94
  95 static int is_relative(int64_t ts) {
  96     return ts > (RELATIVE_TS_BASE - (1LL<<48));
  97 }
  98
  99 /**
 100  * Wrap a given time stamp, if there is an indication for an overflow
 101  *
 102  * @param st stream
 103  * @param timestamp the time stamp to wrap
 104  * @return resulting time stamp
 105  */
 106 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
 107 {
 108     if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
 109         st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
 110         if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
 111             timestamp < st->pts_wrap_reference)
 112             return timestamp + (1ULL << st->pts_wrap_bits);
 113         else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
 114             timestamp >= st->pts_wrap_reference)
 115             return timestamp - (1ULL << st->pts_wrap_bits);
 116     }
 117     return timestamp;
 118 }
 119
 120 #if FF_API_FORMAT_GET_SET
 121 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
 122 #if FF_API_LAVF_FFSERVER
 123 FF_DISABLE_DEPRECATION_WARNINGS
 124 MAKE_ACCESSORS(AVStream, stream, char *, recommended_encoder_configuration)
 125 FF_ENABLE_DEPRECATION_WARNINGS
 126 #endif
 127 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
 128 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
 129 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
 130 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, data_codec)
 131 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
 132 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
 133 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
 134 #if FF_API_OLD_OPEN_CALLBACKS
 135 FF_DISABLE_DEPRECATION_WARNINGS
 136 MAKE_ACCESSORS(AVFormatContext, format, AVOpenCallback, open_cb)
 137 FF_ENABLE_DEPRECATION_WARNINGS
 138 #endif
 139 #endif
 140
 141 int64_t av_stream_get_end_pts(const AVStream *st)
 142 {
 143     if (st->internal->priv_pts) {
 144         return st->internal->priv_pts->val;
 145     } else
 146         return AV_NOPTS_VALUE;
 147 }
 148
 149 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
 150 {
 151     return st->parser;
 152 }
 153
 154 void av_format_inject_global_side_data(AVFormatContext *s)
 155 {
 156     int i;
 157     s->internal->inject_global_side_data = 1;
 158     for (i = 0; i < s->nb_streams; i++) {
 159         AVStream *st = s->streams[i];
 160         st->inject_global_side_data = 1;
 161     }
 162 }
 163
 164 int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
 165 {
 166     av_assert0(!dst->codec_whitelist &&
 167                !dst->format_whitelist &&
 168                !dst->protocol_whitelist &&
 169                !dst->protocol_blacklist);
 170     dst-> codec_whitelist = av_strdup(src->codec_whitelist);
 171     dst->format_whitelist = av_strdup(src->format_whitelist);
 172     dst->protocol_whitelist = av_strdup(src->protocol_whitelist);
 173     dst->protocol_blacklist = av_strdup(src->protocol_blacklist);
 174     if (   (src-> codec_whitelist && !dst-> codec_whitelist)
 175         || (src->  format_whitelist && !dst->  format_whitelist)
 176         || (src->protocol_whitelist && !dst->protocol_whitelist)
 177         || (src->protocol_blacklist && !dst->protocol_blacklist)) {
 178         av_log(dst, AV_LOG_ERROR, "Failed to duplicate black/whitelist\n");
 179         return AVERROR(ENOMEM);
 180     }
 181     return 0;
 182 }
 183
 184 static const AVCodec *find_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
 185 {
 186 #if FF_API_LAVF_AVCTX
 187 FF_DISABLE_DEPRECATION_WARNINGS
 188     if (st->codec->codec)
 189         return st->codec->codec;
 190 FF_ENABLE_DEPRECATION_WARNINGS
 191 #endif
 192
 193     switch (st->codecpar->codec_type) {
 194     case AVMEDIA_TYPE_VIDEO:
 195         if (s->video_codec)    return s->video_codec;
 196         break;
 197     case AVMEDIA_TYPE_AUDIO:
 198         if (s->audio_codec)    return s->audio_codec;
 199         break;
 200     case AVMEDIA_TYPE_SUBTITLE:
 201         if (s->subtitle_codec) return s->subtitle_codec;
 202         break;
 203     }
 204
 205     return avcodec_find_decoder(codec_id);
 206 }
 207
 208 static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id)
 209 {
 210     const AVCodec *codec;
 211
 212 #if CONFIG_H264_DECODER
 213     /* Other parts of the code assume this decoder to be used for h264,
 214      * so force it if possible. */
 215     if (codec_id == AV_CODEC_ID_H264)
 216         return avcodec_find_decoder_by_name("h264");
 217 #endif
 218
 219     codec = find_decoder(s, st, codec_id);
 220     if (!codec)
 221         return NULL;
 222
 223     if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) {
 224         const AVCodec *probe_codec = NULL;
 225         while (probe_codec = av_codec_next(probe_codec)) {
 226             if (probe_codec->id == codec_id &&
 227                     av_codec_is_decoder(probe_codec) &&
 228                     !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) {
 229                 return probe_codec;
 230             }
 231         }
 232     }
 233
 234     return codec;
 235 }
 236
 237 #if FF_API_FORMAT_GET_SET
 238 int av_format_get_probe_score(const AVFormatContext *s)
 239 {
 240     return s->probe_score;
 241 }
 242 #endif
 243
 244 /* an arbitrarily chosen "sane" max packet size -- 50M */
 245 #define SANE_CHUNK_SIZE (50000000)
 246
 247 int ffio_limit(AVIOContext *s, int size)
 248 {
 249     if (s->maxsize>= 0) {
 250         int64_t remaining= s->maxsize - avio_tell(s);
 251         if (remaining < size) {
 252             int64_t newsize = avio_size(s);
 253             if (!s->maxsize || s->maxsize<newsize)
 254                 s->maxsize = newsize - !newsize;
 255             remaining= s->maxsize - avio_tell(s);
 256             remaining= FFMAX(remaining, 0);
 257         }
 258
 259         if (s->maxsize>= 0 && remaining+1 < size) {
 260             av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
 261             size = remaining+1;
 262         }
 263     }
 264     return size;
 265 }
 266
 267 /* Read the data in sane-sized chunks and append to pkt.
 268  * Return the number of bytes read or an error. */
 269 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
 270 {
 271     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
 272     int orig_size      = pkt->size;
 273     int ret;
 274
 275     do {
 276         int prev_size = pkt->size;
 277         int read_size;
 278
 279         /* When the caller requests a lot of data, limit it to the amount
 280          * left in file or SANE_CHUNK_SIZE when it is not known. */
 281         read_size = size;
 282         if (read_size > SANE_CHUNK_SIZE/10) {
 283             read_size = ffio_limit(s, read_size);
 284             // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
 285             if (s->maxsize < 0)
 286                 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
 287         }
 288
 289         ret = av_grow_packet(pkt, read_size);
 290         if (ret < 0)
 291             break;
 292
 293         ret = avio_read(s, pkt->data + prev_size, read_size);
 294         if (ret != read_size) {
 295             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
 296             break;
 297         }
 298
 299         size -= read_size;
 300     } while (size > 0);
 301     if (size > 0)
 302         pkt->flags |= AV_PKT_FLAG_CORRUPT;
 303
 304     pkt->pos = orig_pos;
 305     if (!pkt->size)
 306         av_packet_unref(pkt);
 307     return pkt->size > orig_size ? pkt->size - orig_size : ret;
 308 }
 309
 310 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 311 {
 312     av_init_packet(pkt);
 313     pkt->data = NULL;
 314     pkt->size = 0;
 315     pkt->pos  = avio_tell(s);
 316
 317     return append_packet_chunked(s, pkt, size);
 318 }
 319
 320 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 321 {
 322     if (!pkt->size)
 323         return av_get_packet(s, pkt, size);
 324     return append_packet_chunked(s, pkt, size);
 325 }
 326
 327 int av_filename_number_test(const char *filename)
 328 {
 329     char buf[1024];
 330     return filename &&
 331            (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
 332 }
 333
 334 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
 335                                      AVProbeData *pd)
 336 {
 337     static const struct {
 338         const char *name;
 339         enum AVCodecID id;
 340         enum AVMediaType type;
 341     } fmt_id_type[] = {
 342         { "aac",       AV_CODEC_ID_AAC,        AVMEDIA_TYPE_AUDIO },
 343         { "ac3",       AV_CODEC_ID_AC3,        AVMEDIA_TYPE_AUDIO },
 344         { "aptx",      AV_CODEC_ID_APTX,       AVMEDIA_TYPE_AUDIO },
 345         { "dts",       AV_CODEC_ID_DTS,        AVMEDIA_TYPE_AUDIO },
 346         { "dvbsub",    AV_CODEC_ID_DVB_SUBTITLE,AVMEDIA_TYPE_SUBTITLE },
 347         { "dvbtxt",    AV_CODEC_ID_DVB_TELETEXT,AVMEDIA_TYPE_SUBTITLE },
 348         { "eac3",      AV_CODEC_ID_EAC3,       AVMEDIA_TYPE_AUDIO },
 349         { "h264",      AV_CODEC_ID_H264,       AVMEDIA_TYPE_VIDEO },
 350         { "hevc",      AV_CODEC_ID_HEVC,       AVMEDIA_TYPE_VIDEO },
 351         { "loas",      AV_CODEC_ID_AAC_LATM,   AVMEDIA_TYPE_AUDIO },
 352         { "m4v",       AV_CODEC_ID_MPEG4,      AVMEDIA_TYPE_VIDEO },
 353         { "mjpeg_2000",AV_CODEC_ID_JPEG2000,   AVMEDIA_TYPE_VIDEO },
 354         { "mp3",       AV_CODEC_ID_MP3,        AVMEDIA_TYPE_AUDIO },
 355         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 356         { "truehd",    AV_CODEC_ID_TRUEHD,     AVMEDIA_TYPE_AUDIO },
 357         { 0 }
 358     };
 359     int score;
 360     const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
 361
 362     if (fmt) {
 363         int i;
 364         av_log(s, AV_LOG_DEBUG,
 365                "Probe with size=%d, packets=%d detected %s with score=%d\n",
 366                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
 367                fmt->name, score);
 368         for (i = 0; fmt_id_type[i].name; i++) {
 369             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 370                 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
 371                     st->codecpar->sample_rate)
 372                     continue;
 373                 if (st->request_probe > score &&
 374                     st->codecpar->codec_id != fmt_id_type[i].id)
 375                     continue;
 376                 st->codecpar->codec_id   = fmt_id_type[i].id;
 377                 st->codecpar->codec_type = fmt_id_type[i].type;
 378                 st->internal->need_context_update = 1;
 379 #if FF_API_LAVF_AVCTX
 380 FF_DISABLE_DEPRECATION_WARNINGS
 381                 st->codec->codec_type = st->codecpar->codec_type;
 382                 st->codec->codec_id   = st->codecpar->codec_id;
 383 FF_ENABLE_DEPRECATION_WARNINGS
 384 #endif
 385                 return score;
 386             }
 387         }
 388     }
 389     return 0;
 390 }
 391
 392 /************************************************************/
 393 /* input media file */
 394
 395 int av_demuxer_open(AVFormatContext *ic) {
 396     int err;
 397
 398     if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
 399         av_log(ic, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", ic->format_whitelist);
 400         return AVERROR(EINVAL);
 401     }
 402
 403     if (ic->iformat->read_header) {
 404         err = ic->iformat->read_header(ic);
 405         if (err < 0)
 406             return err;
 407     }
 408
 409     if (ic->pb && !ic->internal->data_offset)
 410         ic->internal->data_offset = avio_tell(ic->pb);
 411
 412     return 0;
 413 }
 414
 415 /* Open input file and probe the format if necessary. */
 416 static int init_input(AVFormatContext *s, const char *filename,
 417                       AVDictionary **options)
 418 {
 419     int ret;
 420     AVProbeData pd = { filename, NULL, 0 };
 421     int score = AVPROBE_SCORE_RETRY;
 422
 423     if (s->pb) {
 424         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 425         if (!s->iformat)
 426             return av_probe_input_buffer2(s->pb, &s->iformat, filename,
 427                                          s, 0, s->format_probesize);
 428         else if (s->iformat->flags & AVFMT_NOFILE)
 429             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
 430                                       "will be ignored with AVFMT_NOFILE format.\n");
 431         return 0;
 432     }
 433
 434     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
 435         (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
 436         return score;
 437
 438     if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
 439         return ret;
 440
 441     if (s->iformat)
 442         return 0;
 443     return av_probe_input_buffer2(s->pb, &s->iformat, filename,
 444                                  s, 0, s->format_probesize);
 445 }
 446
 447 int ff_packet_list_put(AVPacketList **packet_buffer,
 448                        AVPacketList **plast_pktl,
 449                        AVPacket      *pkt, int flags)
 450 {
 451     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 452     int ret;
 453
 454     if (!pktl)
 455         return AVERROR(ENOMEM);
 456
 457     if (flags & FF_PACKETLIST_FLAG_REF_PACKET) {
 458         if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
 459             av_free(pktl);
 460             return ret;
 461         }
 462     } else {
 463         // TODO: Adapt callers in this file so the line below can use
 464         //       av_packet_move_ref() to effectively move the reference
 465         //       to the list.
 466         pktl->pkt = *pkt;
 467     }
 468
 469     if (*packet_buffer)
 470         (*plast_pktl)->next = pktl;
 471     else
 472         *packet_buffer = pktl;
 473
 474     /* Add the packet in the buffered packet list. */
 475     *plast_pktl = pktl;
 476     return 0;
 477 }
 478
 479 int avformat_queue_attached_pictures(AVFormatContext *s)
 480 {
 481     int i, ret;
 482     for (i = 0; i < s->nb_streams; i++)
 483         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
 484             s->streams[i]->discard < AVDISCARD_ALL) {
 485             if (s->streams[i]->attached_pic.size <= 0) {
 486                 av_log(s, AV_LOG_WARNING,
 487                     "Attached picture on stream %d has invalid size, "
 488                     "ignoring\n", i);
 489                 continue;
 490             }
 491
 492             ret = ff_packet_list_put(&s->internal->raw_packet_buffer,
 493                                      &s->internal->raw_packet_buffer_end,
 494                                      &s->streams[i]->attached_pic,
 495                                      FF_PACKETLIST_FLAG_REF_PACKET);
 496             if (ret < 0)
 497                 return ret;
 498         }
 499     return 0;
 500 }
 501
 502 static int update_stream_avctx(AVFormatContext *s)
 503 {
 504     int i, ret;
 505     for (i = 0; i < s->nb_streams; i++) {
 506         AVStream *st = s->streams[i];
 507
 508         if (!st->internal->need_context_update)
 509             continue;
 510
 511         /* close parser, because it depends on the codec */
 512         if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
 513             av_parser_close(st->parser);
 514             st->parser = NULL;
 515         }
 516
 517         /* update internal codec context, for the parser */
 518         ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
 519         if (ret < 0)
 520             return ret;
 521
 522 #if FF_API_LAVF_AVCTX
 523 FF_DISABLE_DEPRECATION_WARNINGS
 524         /* update deprecated public codec context */
 525         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
 526         if (ret < 0)
 527             return ret;
 528 FF_ENABLE_DEPRECATION_WARNINGS
 529 #endif
 530
 531         st->internal->need_context_update = 0;
 532     }
 533     return 0;
 534 }
 535
 536
 537 int avformat_open_input(AVFormatContext **ps, const char *filename,
 538                         ff_const59 AVInputFormat *fmt, AVDictionary **options)
 539 {
 540     AVFormatContext *s = *ps;
 541     int i, ret = 0;
 542     AVDictionary *tmp = NULL;
 543     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
 544
 545     if (!s && !(s = avformat_alloc_context()))
 546         return AVERROR(ENOMEM);
 547     if (!s->av_class) {
 548         av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
 549         return AVERROR(EINVAL);
 550     }
 551     if (fmt)
 552         s->iformat = fmt;
 553
 554     if (options)
 555         av_dict_copy(&tmp, *options, 0);
 556
 557     if (s->pb) // must be before any goto fail
 558         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 559
 560     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
 561         goto fail;
 562
 563     if (!(s->url = av_strdup(filename ? filename : ""))) {
 564         ret = AVERROR(ENOMEM);
 565         goto fail;
 566     }
 567
 568 #if FF_API_FORMAT_FILENAME
 569 FF_DISABLE_DEPRECATION_WARNINGS
 570     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
 571 FF_ENABLE_DEPRECATION_WARNINGS
 572 #endif
 573     if ((ret = init_input(s, filename, &tmp)) < 0)
 574         goto fail;
 575     s->probe_score = ret;
 576
 577     if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
 578         s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
 579         if (!s->protocol_whitelist) {
 580             ret = AVERROR(ENOMEM);
 581             goto fail;
 582         }
 583     }
 584
 585     if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) {
 586         s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
 587         if (!s->protocol_blacklist) {
 588             ret = AVERROR(ENOMEM);
 589             goto fail;
 590         }
 591     }
 592
 593     if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
 594         av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
 595         ret = AVERROR(EINVAL);
 596         goto fail;
 597     }
 598
 599     avio_skip(s->pb, s->skip_initial_bytes);
 600
 601     /* Check filename in case an image number is expected. */
 602     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
 603         if (!av_filename_number_test(filename)) {
 604             ret = AVERROR(EINVAL);
 605             goto fail;
 606         }
 607     }
 608
 609     s->duration = s->start_time = AV_NOPTS_VALUE;
 610
 611     /* Allocate private data. */
 612     if (s->iformat->priv_data_size > 0) {
 613         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
 614             ret = AVERROR(ENOMEM);
 615             goto fail;
 616         }
 617         if (s->iformat->priv_class) {
 618             *(const AVClass **) s->priv_data = s->iformat->priv_class;
 619             av_opt_set_defaults(s->priv_data);
 620             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 621                 goto fail;
 622         }
 623     }
 624
 625     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
 626     if (s->pb)
 627         ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
 628
 629
 630     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
 631         if ((ret = s->iformat->read_header(s)) < 0)
 632             goto fail;
 633
 634     if (!s->metadata) {
 635         s->metadata = s->internal->id3v2_meta;
 636         s->internal->id3v2_meta = NULL;
 637     } else if (s->internal->id3v2_meta) {
 638         int level = AV_LOG_WARNING;
 639         if (s->error_recognition & AV_EF_COMPLIANT)
 640             level = AV_LOG_ERROR;
 641         av_log(s, level, "Discarding ID3 tags because more suitable tags were found.\n");
 642         av_dict_free(&s->internal->id3v2_meta);
 643         if (s->error_recognition & AV_EF_EXPLODE)
 644             return AVERROR_INVALIDDATA;
 645     }
 646
 647     if (id3v2_extra_meta) {
 648         if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
 649             !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) {
 650             if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
 651                 goto fail;
 652             if ((ret = ff_id3v2_parse_chapters(s, &id3v2_extra_meta)) < 0)
 653                 goto fail;
 654             if ((ret = ff_id3v2_parse_priv(s, &id3v2_extra_meta)) < 0)
 655                 goto fail;
 656         } else
 657             av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
 658     }
 659     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 660
 661     if ((ret = avformat_queue_attached_pictures(s)) < 0)
 662         goto fail;
 663
 664     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
 665         s->internal->data_offset = avio_tell(s->pb);
 666
 667     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 668
 669     update_stream_avctx(s);
 670
 671     for (i = 0; i < s->nb_streams; i++)
 672         s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
 673
 674     if (options) {
 675         av_dict_free(options);
 676         *options = tmp;
 677     }
 678     *ps = s;
 679     return 0;
 680
 681 fail:
 682     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 683     av_dict_free(&tmp);
 684     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
 685         avio_closep(&s->pb);
 686     avformat_free_context(s);
 687     *ps = NULL;
 688     return ret;
 689 }
 690
 691 /*******************************************************/
 692
 693 static void force_codec_ids(AVFormatContext *s, AVStream *st)
 694 {
 695     switch (st->codecpar->codec_type) {
 696     case AVMEDIA_TYPE_VIDEO:
 697         if (s->video_codec_id)
 698             st->codecpar->codec_id = s->video_codec_id;
 699         break;
 700     case AVMEDIA_TYPE_AUDIO:
 701         if (s->audio_codec_id)
 702             st->codecpar->codec_id = s->audio_codec_id;
 703         break;
 704     case AVMEDIA_TYPE_SUBTITLE:
 705         if (s->subtitle_codec_id)
 706             st->codecpar->codec_id = s->subtitle_codec_id;
 707         break;
 708     case AVMEDIA_TYPE_DATA:
 709         if (s->data_codec_id)
 710             st->codecpar->codec_id = s->data_codec_id;
 711         break;
 712     }
 713 }
 714
 715 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
 716 {
 717     if (st->request_probe>0) {
 718         AVProbeData *pd = &st->probe_data;
 719         int end;
 720         av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
 721         --st->probe_packets;
 722
 723         if (pkt) {
 724             uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
 725             if (!new_buf) {
 726                 av_log(s, AV_LOG_WARNING,
 727                        "Failed to reallocate probe buffer for stream %d\n",
 728                        st->index);
 729                 goto no_packet;
 730             }
 731             pd->buf = new_buf;
 732             memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
 733             pd->buf_size += pkt->size;
 734             memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 735         } else {
 736 no_packet:
 737             st->probe_packets = 0;
 738             if (!pd->buf_size) {
 739                 av_log(s, AV_LOG_WARNING,
 740                        "nothing to probe for stream %d\n", st->index);
 741             }
 742         }
 743
 744         end=    s->internal->raw_packet_buffer_remaining_size <= 0
 745                 || st->probe_packets<= 0;
 746
 747         if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
 748             int score = set_codec_from_probe_data(s, st, pd);
 749             if (    (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
 750                 || end) {
 751                 pd->buf_size = 0;
 752                 av_freep(&pd->buf);
 753                 st->request_probe = -1;
 754                 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
 755                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 756                 } else
 757                     av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
 758             }
 759             force_codec_ids(s, st);
 760         }
 761     }
 762     return 0;
 763 }
 764
 765 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
 766 {
 767     int64_t ref = pkt->dts;
 768     int i, pts_wrap_behavior;
 769     int64_t pts_wrap_reference;
 770     AVProgram *first_program;
 771
 772     if (ref == AV_NOPTS_VALUE)
 773         ref = pkt->pts;
 774     if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
 775         return 0;
 776     ref &= (1LL << st->pts_wrap_bits)-1;
 777
 778     // reference time stamp should be 60 s before first time stamp
 779     pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
 780     // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
 781     pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
 782         (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
 783         AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
 784
 785     first_program = av_find_program_from_stream(s, NULL, stream_index);
 786
 787     if (!first_program) {
 788         int default_stream_index = av_find_default_stream_index(s);
 789         if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
 790             for (i = 0; i < s->nb_streams; i++) {
 791                 if (av_find_program_from_stream(s, NULL, i))
 792                     continue;
 793                 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
 794                 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
 795             }
 796         }
 797         else {
 798             st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
 799             st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
 800         }
 801     }
 802     else {
 803         AVProgram *program = first_program;
 804         while (program) {
 805             if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
 806                 pts_wrap_reference = program->pts_wrap_reference;
 807                 pts_wrap_behavior = program->pts_wrap_behavior;
 808                 break;
 809             }
 810             program = av_find_program_from_stream(s, program, stream_index);
 811         }
 812
 813         // update every program with differing pts_wrap_reference
 814         program = first_program;
 815         while (program) {
 816             if (program->pts_wrap_reference != pts_wrap_reference) {
 817                 for (i = 0; i<program->nb_stream_indexes; i++) {
 818                     s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
 819                     s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
 820                 }
 821
 822                 program->pts_wrap_reference = pts_wrap_reference;
 823                 program->pts_wrap_behavior = pts_wrap_behavior;
 824             }
 825             program = av_find_program_from_stream(s, program, stream_index);
 826         }
 827     }
 828     return 1;
 829 }
 830
 831 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
 832 {
 833     int ret, i, err;
 834     AVStream *st;
 835
 836     for (;;) {
 837         AVPacketList *pktl = s->internal->raw_packet_buffer;
 838
 839         if (pktl) {
 840             *pkt = pktl->pkt;
 841             st   = s->streams[pkt->stream_index];
 842             if (s->internal->raw_packet_buffer_remaining_size <= 0)
 843                 if ((err = probe_codec(s, st, NULL)) < 0)
 844                     return err;
 845             if (st->request_probe <= 0) {
 846                 s->internal->raw_packet_buffer                 = pktl->next;
 847                 s->internal->raw_packet_buffer_remaining_size += pkt->size;
 848                 av_free(pktl);
 849                 return 0;
 850             }
 851         }
 852
 853         pkt->data = NULL;
 854         pkt->size = 0;
 855         av_init_packet(pkt);
 856         ret = s->iformat->read_packet(s, pkt);
 857         if (ret < 0) {
 858             /* Some demuxers return FFERROR_REDO when they consume
 859                data and discard it (ignored streams, junk, extradata).
 860                We must re-call the demuxer to get the real packet. */
 861             if (ret == FFERROR_REDO)
 862                 continue;
 863             if (!pktl || ret == AVERROR(EAGAIN))
 864                 return ret;
 865             for (i = 0; i < s->nb_streams; i++) {
 866                 st = s->streams[i];
 867                 if (st->probe_packets || st->request_probe > 0)
 868                     if ((err = probe_codec(s, st, NULL)) < 0)
 869                         return err;
 870                 av_assert0(st->request_probe <= 0);
 871             }
 872             continue;
 873         }
 874
 875         err = av_packet_make_refcounted(pkt);
 876         if (err < 0)
 877             return err;
 878
 879         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
 880             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
 881             av_log(s, AV_LOG_WARNING,
 882                    "Dropped corrupted packet (stream = %d)\n",
 883                    pkt->stream_index);
 884             av_packet_unref(pkt);
 885             continue;
 886         }
 887
 888         if (pkt->stream_index >= (unsigned)s->nb_streams) {
 889             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
 890             continue;
 891         }
 892
 893         st = s->streams[pkt->stream_index];
 894
 895         if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
 896             // correct first time stamps to negative values
 897             if (!is_relative(st->first_dts))
 898                 st->first_dts = wrap_timestamp(st, st->first_dts);
 899             if (!is_relative(st->start_time))
 900                 st->start_time = wrap_timestamp(st, st->start_time);
 901             if (!is_relative(st->cur_dts))
 902                 st->cur_dts = wrap_timestamp(st, st->cur_dts);
 903         }
 904
 905         pkt->dts = wrap_timestamp(st, pkt->dts);
 906         pkt->pts = wrap_timestamp(st, pkt->pts);
 907
 908         force_codec_ids(s, st);
 909
 910         /* TODO: audio: time filter; video: frame reordering (pts != dts) */
 911         if (s->use_wallclock_as_timestamps)
 912             pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
 913
 914         if (!pktl && st->request_probe <= 0)
 915             return ret;
 916
 917         err = ff_packet_list_put(&s->internal->raw_packet_buffer,
 918                                  &s->internal->raw_packet_buffer_end,
 919                                  pkt, 0);
 920         if (err)
 921             return err;
 922         s->internal->raw_packet_buffer_remaining_size -= pkt->size;
 923
 924         if ((err = probe_codec(s, st, pkt)) < 0)
 925             return err;
 926     }
 927 }
 928
 929
 930 /**********************************************************/
 931
 932 static int determinable_frame_size(AVCodecContext *avctx)
 933 {
 934     switch(avctx->codec_id) {
 935     case AV_CODEC_ID_MP1:
 936     case AV_CODEC_ID_MP2:
 937     case AV_CODEC_ID_MP3:
 938     case AV_CODEC_ID_CODEC2:
 939         return 1;
 940     }
 941
 942     return 0;
 943 }
 944
 945 /**
 946  * Return the frame duration in seconds. Return 0 if not available.
 947  */
 948 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
 949                                AVCodecParserContext *pc, AVPacket *pkt)
 950 {
 951     AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
 952                                               av_mul_q(av_inv_q(st->internal->avctx->time_base), (AVRational){1, st->internal->avctx->ticks_per_frame});
 953     int frame_size, sample_rate;
 954
 955 #if FF_API_LAVF_AVCTX
 956 FF_DISABLE_DEPRECATION_WARNINGS
 957     if ((!codec_framerate.den || !codec_framerate.num) && st->codec->time_base.den && st->codec->time_base.num)
 958         codec_framerate = av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
 959 FF_ENABLE_DEPRECATION_WARNINGS
 960 #endif
 961
 962     *pnum = 0;
 963     *pden = 0;
 964     switch (st->codecpar->codec_type) {
 965     case AVMEDIA_TYPE_VIDEO:
 966         if (st->r_frame_rate.num && !pc && s->iformat) {
 967             *pnum = st->r_frame_rate.den;
 968             *pden = st->r_frame_rate.num;
 969         } else if (st->time_base.num * 1000LL > st->time_base.den) {
 970             *pnum = st->time_base.num;
 971             *pden = st->time_base.den;
 972         } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
 973             av_assert0(st->internal->avctx->ticks_per_frame);
 974             av_reduce(pnum, pden,
 975                       codec_framerate.den,
 976                       codec_framerate.num * (int64_t)st->internal->avctx->ticks_per_frame,
 977                       INT_MAX);
 978
 979             if (pc && pc->repeat_pict) {
 980                 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
 981                 av_reduce(pnum, pden,
 982                           (*pnum) * (1LL + pc->repeat_pict),
 983                           (*pden),
 984                           INT_MAX);
 985             }
 986             /* If this codec can be interlaced or progressive then we need
 987              * a parser to compute duration of a packet. Thus if we have
 988              * no parser in such case leave duration undefined. */
 989             if (st->internal->avctx->ticks_per_frame > 1 && !pc)
 990                 *pnum = *pden = 0;
 991         }
 992         break;
 993     case AVMEDIA_TYPE_AUDIO:
 994         if (st->internal->avctx_inited) {
 995             frame_size = av_get_audio_frame_duration(st->internal->avctx, pkt->size);
 996             sample_rate = st->internal->avctx->sample_rate;
 997         } else {
 998             frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
 999             sample_rate = st->codecpar->sample_rate;
1000         }
1001         if (frame_size <= 0 || sample_rate <= 0)
1002             break;
1003         *pnum = frame_size;
1004         *pden = sample_rate;
1005         break;
1006     default:
1007         break;
1008     }
1009 }
1010
1011 static int is_intra_only(enum AVCodecID id)
1012 {
1013     const AVCodecDescriptor *d = avcodec_descriptor_get(id);
1014     if (!d)
1015         return 0;
1016     if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
1017         return 0;
1018     return 1;
1019 }
1020
1021 static int has_decode_delay_been_guessed(AVStream *st)
1022 {
1023     if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
1024     if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
1025         return 1;
1026 #if CONFIG_H264_DECODER
1027     if (st->internal->avctx->has_b_frames &&
1028        avpriv_h264_has_num_reorder_frames(st->internal->avctx) == st->internal->avctx->has_b_frames)
1029         return 1;
1030 #endif
1031     if (st->internal->avctx->has_b_frames<3)
1032         return st->nb_decoded_frames >= 7;
1033     else if (st->internal->avctx->has_b_frames<4)
1034         return st->nb_decoded_frames >= 18;
1035     else
1036         return st->nb_decoded_frames >= 20;
1037 }
1038
1039 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
1040 {
1041     if (pktl->next)
1042         return pktl->next;
1043     if (pktl == s->internal->packet_buffer_end)
1044         return s->internal->parse_queue;
1045     return NULL;
1046 }
1047
1048 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
1049     int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1050                        st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1051
1052     if(!onein_oneout) {
1053         int delay = st->internal->avctx->has_b_frames;
1054         int i;
1055
1056         if (dts == AV_NOPTS_VALUE) {
1057             int64_t best_score = INT64_MAX;
1058             for (i = 0; i<delay; i++) {
1059                 if (st->pts_reorder_error_count[i]) {
1060                     int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1061                     if (score < best_score) {
1062                         best_score = score;
1063                         dts = pts_buffer[i];
1064                     }
1065                 }
1066             }
1067         } else {
1068             for (i = 0; i<delay; i++) {
1069                 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1070                     int64_t diff =  FFABS(pts_buffer[i] - dts)
1071                                     + (uint64_t)st->pts_reorder_error[i];
1072                     diff = FFMAX(diff, st->pts_reorder_error[i]);
1073                     st->pts_reorder_error[i] = diff;
1074                     st->pts_reorder_error_count[i]++;
1075                     if (st->pts_reorder_error_count[i] > 250) {
1076                         st->pts_reorder_error[i] >>= 1;
1077                         st->pts_reorder_error_count[i] >>= 1;
1078                     }
1079                 }
1080             }
1081         }
1082     }
1083
1084     if (dts == AV_NOPTS_VALUE)
1085         dts = pts_buffer[0];
1086
1087     return dts;
1088 }
1089
1090 /**
1091  * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts
1092  * of the packets in a window.
1093  */
1094 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
1095                                 AVPacketList *pkt_buffer)
1096 {
1097     AVStream *st       = s->streams[stream_index];
1098     int delay          = st->internal->avctx->has_b_frames;
1099     int i;
1100
1101     int64_t pts_buffer[MAX_REORDER_DELAY+1];
1102
1103     for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1104         pts_buffer[i] = AV_NOPTS_VALUE;
1105
1106     for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
1107         if (pkt_buffer->pkt.stream_index != stream_index)
1108             continue;
1109
1110         if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1111             pts_buffer[0] = pkt_buffer->pkt.pts;
1112             for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1113                 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1114
1115             pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
1116         }
1117     }
1118 }
1119
1120 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1121                                       int64_t dts, int64_t pts, AVPacket *pkt)
1122 {
1123     AVStream *st       = s->streams[stream_index];
1124     AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1125     AVPacketList *pktl_it;
1126
1127     uint64_t shift;
1128
1129     if (st->first_dts != AV_NOPTS_VALUE ||
1130         dts           == AV_NOPTS_VALUE ||
1131         st->cur_dts   == AV_NOPTS_VALUE ||
1132         st->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
1133         is_relative(dts))
1134         return;
1135
1136     st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1137     st->cur_dts   = dts;
1138     shift         = (uint64_t)st->first_dts - RELATIVE_TS_BASE;
1139
1140     if (is_relative(pts))
1141         pts += shift;
1142
1143     for (pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
1144         if (pktl_it->pkt.stream_index != stream_index)
1145             continue;
1146         if (is_relative(pktl_it->pkt.pts))
1147             pktl_it->pkt.pts += shift;
1148
1149         if (is_relative(pktl_it->pkt.dts))
1150             pktl_it->pkt.dts += shift;
1151
1152         if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) {
1153             st->start_time = pktl_it->pkt.pts;
1154             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1155                 st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1156         }
1157     }
1158
1159     if (has_decode_delay_been_guessed(st)) {
1160         update_dts_from_pts(s, stream_index, pktl);
1161     }
1162
1163     if (st->start_time == AV_NOPTS_VALUE) {
1164         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
1165             st->start_time = pts;
1166         }
1167         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
1168             st->start_time += av_rescale_q(st->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base);
1169     }
1170 }
1171
1172 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1173                                      int stream_index, int duration)
1174 {
1175     AVPacketList *pktl = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1176     int64_t cur_dts    = RELATIVE_TS_BASE;
1177
1178     if (st->first_dts != AV_NOPTS_VALUE) {
1179         if (st->update_initial_durations_done)
1180             return;
1181         st->update_initial_durations_done = 1;
1182         cur_dts = st->first_dts;
1183         for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1184             if (pktl->pkt.stream_index == stream_index) {
1185                 if (pktl->pkt.pts != pktl->pkt.dts  ||
1186                     pktl->pkt.dts != AV_NOPTS_VALUE ||
1187                     pktl->pkt.duration)
1188                     break;
1189                 cur_dts -= duration;
1190             }
1191         }
1192         if (pktl && pktl->pkt.dts != st->first_dts) {
1193             av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n",
1194                    av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1195             return;
1196         }
1197         if (!pktl) {
1198             av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1199             return;
1200         }
1201         pktl          = s->internal->packet_buffer ? s->internal->packet_buffer : s->internal->parse_queue;
1202         st->first_dts = cur_dts;
1203     } else if (st->cur_dts != RELATIVE_TS_BASE)
1204         return;
1205
1206     for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1207         if (pktl->pkt.stream_index != stream_index)
1208             continue;
1209         if ((pktl->pkt.pts == pktl->pkt.dts ||
1210              pktl->pkt.pts == AV_NOPTS_VALUE) &&
1211             (pktl->pkt.dts == AV_NOPTS_VALUE ||
1212              pktl->pkt.dts == st->first_dts ||
1213              pktl->pkt.dts == RELATIVE_TS_BASE) &&
1214             !pktl->pkt.duration) {
1215             pktl->pkt.dts = cur_dts;
1216             if (!st->internal->avctx->has_b_frames)
1217                 pktl->pkt.pts = cur_dts;
1218 //            if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
1219                 pktl->pkt.duration = duration;
1220         } else
1221             break;
1222         cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1223     }
1224     if (!pktl)
1225         st->cur_dts = cur_dts;
1226 }
1227
1228 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1229                                AVCodecParserContext *pc, AVPacket *pkt,
1230                                int64_t next_dts, int64_t next_pts)
1231 {
1232     int num, den, presentation_delayed, delay, i;
1233     int64_t offset;
1234     AVRational duration;
1235     int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
1236                        st->codecpar->codec_id != AV_CODEC_ID_HEVC;
1237
1238     if (s->flags & AVFMT_FLAG_NOFILLIN)
1239         return;
1240
1241     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1242         if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1243             if (st->last_dts_for_order_check <= pkt->dts) {
1244                 st->dts_ordered++;
1245             } else {
1246                 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1247                        "DTS %"PRIi64" < %"PRIi64" out of order\n",
1248                        pkt->dts,
1249                        st->last_dts_for_order_check);
1250                 st->dts_misordered++;
1251             }
1252             if (st->dts_ordered + st->dts_misordered > 250) {
1253                 st->dts_ordered    >>= 1;
1254                 st->dts_misordered >>= 1;
1255             }
1256         }
1257
1258         st->last_dts_for_order_check = pkt->dts;
1259         if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1260             pkt->dts = AV_NOPTS_VALUE;
1261     }
1262
1263     if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1264         pkt->dts = AV_NOPTS_VALUE;
1265
1266     if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1267         && !st->internal->avctx->has_b_frames)
1268         //FIXME Set low_delay = 0 when has_b_frames = 1
1269         st->internal->avctx->has_b_frames = 1;
1270
1271     /* do we have a video B-frame ? */
1272     delay = st->internal->avctx->has_b_frames;
1273     presentation_delayed = 0;
1274
1275     /* XXX: need has_b_frame, but cannot get it if the codec is
1276      *  not initialized */
1277     if (delay &&
1278         pc && pc->pict_type != AV_PICTURE_TYPE_B)
1279         presentation_delayed = 1;
1280
1281     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1282         st->pts_wrap_bits < 63 &&
1283         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1284         if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1285             pkt->dts -= 1LL << st->pts_wrap_bits;
1286         } else
1287             pkt->pts += 1LL << st->pts_wrap_bits;
1288     }
1289
1290     /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1291      * We take the conservative approach and discard both.
1292      * Note: If this is misbehaving for an H.264 file, then possibly
1293      * presentation_delayed is not set correctly. */
1294     if (delay == 1 && pkt->dts == pkt->pts &&
1295         pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1296         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1297         if (    strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1298              && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1299             pkt->dts = AV_NOPTS_VALUE;
1300     }
1301
1302     duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1303     if (pkt->duration == 0) {
1304         ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1305         if (den && num) {
1306             duration = (AVRational) {num, den};
1307             pkt->duration = av_rescale_rnd(1,
1308                                            num * (int64_t) st->time_base.den,
1309                                            den * (int64_t) st->time_base.num,
1310                                            AV_ROUND_DOWN);
1311         }
1312     }
1313
1314     if (pkt->duration != 0 && (s->internal->packet_buffer || s->internal->parse_queue))
1315         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1316
1317     /* Correct timestamps with byte offset if demuxers only have timestamps
1318      * on packet boundaries */
1319     if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1320         /* this will estimate bitrate based on this frame's duration and size */
1321         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1322         if (pkt->pts != AV_NOPTS_VALUE)
1323             pkt->pts += offset;
1324         if (pkt->dts != AV_NOPTS_VALUE)
1325             pkt->dts += offset;
1326     }
1327
1328     /* This may be redundant, but it should not hurt. */
1329     if (pkt->dts != AV_NOPTS_VALUE &&
1330         pkt->pts != AV_NOPTS_VALUE &&
1331         pkt->pts > pkt->dts)
1332         presentation_delayed = 1;
1333
1334     if (s->debug & FF_FDEBUG_TS)
1335         av_log(s, AV_LOG_DEBUG,
1336             "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n",
1337             presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1338             pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1339
1340     /* Interpolate PTS and DTS if they are not present. We skip H264
1341      * currently because delay and has_b_frames are not reliably set. */
1342     if ((delay == 0 || (delay == 1 && pc)) &&
1343         onein_oneout) {
1344         if (presentation_delayed) {
1345             /* DTS = decompression timestamp */
1346             /* PTS = presentation timestamp */
1347             if (pkt->dts == AV_NOPTS_VALUE)
1348                 pkt->dts = st->last_IP_pts;
1349             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1350             if (pkt->dts == AV_NOPTS_VALUE)
1351                 pkt->dts = st->cur_dts;
1352
1353             /* This is tricky: the dts must be incremented by the duration
1354              * of the frame we are displaying, i.e. the last I- or P-frame. */
1355             if (st->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1356                 st->last_IP_duration = pkt->duration;
1357             if (pkt->dts != AV_NOPTS_VALUE)
1358                 st->cur_dts = pkt->dts + st->last_IP_duration;
1359             if (pkt->dts != AV_NOPTS_VALUE &&
1360                 pkt->pts == AV_NOPTS_VALUE &&
1361                 st->last_IP_duration > 0 &&
1362                 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1363                 next_dts != next_pts &&
1364                 next_pts != AV_NOPTS_VALUE)
1365                 pkt->pts = next_dts;
1366
1367             if ((uint64_t)pkt->duration <= INT32_MAX)
1368                 st->last_IP_duration = pkt->duration;
1369             st->last_IP_pts      = pkt->pts;
1370             /* Cannot compute PTS if not present (we can compute it only
1371              * by knowing the future. */
1372         } else if (pkt->pts != AV_NOPTS_VALUE ||
1373                    pkt->dts != AV_NOPTS_VALUE ||
1374                    pkt->duration                ) {
1375
1376             /* presentation is not delayed : PTS and DTS are the same */
1377             if (pkt->pts == AV_NOPTS_VALUE)
1378                 pkt->pts = pkt->dts;
1379             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1380                                       pkt->pts, pkt);
1381             if (pkt->pts == AV_NOPTS_VALUE)
1382                 pkt->pts = st->cur_dts;
1383             pkt->dts = pkt->pts;
1384             if (pkt->pts != AV_NOPTS_VALUE)
1385                 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1386         }
1387     }
1388
1389     if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1390         st->pts_buffer[0] = pkt->pts;
1391         for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1392             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1393
1394         if(has_decode_delay_been_guessed(st))
1395             pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1396     }
1397     // We skipped it above so we try here.
1398     if (!onein_oneout)
1399         // This should happen on the first packet
1400         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1401     if (pkt->dts > st->cur_dts)
1402         st->cur_dts = pkt->dts;
1403
1404     if (s->debug & FF_FDEBUG_TS)
1405         av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n",
1406             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), st->index, st->id);
1407
1408     /* update flags */
1409     if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || is_intra_only(st->codecpar->codec_id))
1410         pkt->flags |= AV_PKT_FLAG_KEY;
1411 #if FF_API_CONVERGENCE_DURATION
1412 FF_DISABLE_DEPRECATION_WARNINGS
1413     if (pc)
1414         pkt->convergence_duration = pc->convergence_duration;
1415 FF_ENABLE_DEPRECATION_WARNINGS
1416 #endif
1417 }
1418
1419 void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1420 {
1421     AVPacketList *tmp = *pkt_buf;
1422
1423     while (tmp) {
1424         AVPacketList *pktl = tmp;
1425         tmp = pktl->next;
1426         av_packet_unref(&pktl->pkt);
1427         av_freep(&pktl);
1428     }
1429     *pkt_buf     = NULL;
1430     *pkt_buf_end = NULL;
1431 }
1432
1433 /**
1434  * Parse a packet, add all split parts to parse_queue.
1435  *
1436  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1437  */
1438 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1439 {
1440     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1441     AVStream *st = s->streams[stream_index];
1442     uint8_t *data = pkt ? pkt->data : NULL;
1443     int size      = pkt ? pkt->size : 0;
1444     int ret = 0, got_output = 0;
1445
1446     if (!pkt) {
1447         av_init_packet(&flush_pkt);
1448         pkt        = &flush_pkt;
1449         got_output = 1;
1450     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1451         // preserve 0-size sync packets
1452         compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1453     }
1454
1455     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1456         int len;
1457         int64_t next_pts = pkt->pts;
1458         int64_t next_dts = pkt->dts;
1459
1460         av_init_packet(&out_pkt);
1461         len = av_parser_parse2(st->parser, st->internal->avctx,
1462                                &out_pkt.data, &out_pkt.size, data, size,
1463                                pkt->pts, pkt->dts, pkt->pos);
1464
1465         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1466         pkt->pos = -1;
1467         /* increment read pointer */
1468         data += len;
1469         size -= len;
1470
1471         got_output = !!out_pkt.size;
1472
1473         if (!out_pkt.size)
1474             continue;
1475
1476         if (pkt->buf && out_pkt.data == pkt->data) {
1477             /* reference pkt->buf only when out_pkt.data is guaranteed to point
1478              * to data in it and not in the parser's internal buffer. */
1479             /* XXX: Ensure this is the case with all parsers when st->parser->flags
1480              * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1481             out_pkt.buf = av_buffer_ref(pkt->buf);
1482             if (!out_pkt.buf) {
1483                 ret = AVERROR(ENOMEM);
1484                 goto fail;
1485             }
1486         } else {
1487             ret = av_packet_make_refcounted(&out_pkt);
1488             if (ret < 0)
1489                 goto fail;
1490         }
1491
1492         if (pkt->side_data) {
1493             out_pkt.side_data       = pkt->side_data;
1494             out_pkt.side_data_elems = pkt->side_data_elems;
1495             pkt->side_data          = NULL;
1496             pkt->side_data_elems    = 0;
1497         }
1498
1499         /* set the duration */
1500         out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1501         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1502             if (st->internal->avctx->sample_rate > 0) {
1503                 out_pkt.duration =
1504                     av_rescale_q_rnd(st->parser->duration,
1505                                      (AVRational) { 1, st->internal->avctx->sample_rate },
1506                                      st->time_base,
1507                                      AV_ROUND_DOWN);
1508             }
1509         }
1510
1511         out_pkt.stream_index = st->index;
1512         out_pkt.pts          = st->parser->pts;
1513         out_pkt.dts          = st->parser->dts;
1514         out_pkt.pos          = st->parser->pos;
1515         out_pkt.flags       |= pkt->flags & AV_PKT_FLAG_DISCARD;
1516
1517         if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1518             out_pkt.pos = st->parser->frame_offset;
1519
1520         if (st->parser->key_frame == 1 ||
1521             (st->parser->key_frame == -1 &&
1522              st->parser->pict_type == AV_PICTURE_TYPE_I))
1523             out_pkt.flags |= AV_PKT_FLAG_KEY;
1524
1525         if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1526             out_pkt.flags |= AV_PKT_FLAG_KEY;
1527
1528         compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1529
1530         ret = ff_packet_list_put(&s->internal->parse_queue,
1531                                  &s->internal->parse_queue_end,
1532                                  &out_pkt, 0);
1533         if (ret < 0) {
1534             av_packet_unref(&out_pkt);
1535             goto fail;
1536         }
1537     }
1538
1539     /* end of the stream => close and free the parser */
1540     if (pkt == &flush_pkt) {
1541         av_parser_close(st->parser);
1542         st->parser = NULL;
1543     }
1544
1545 fail:
1546     av_packet_unref(pkt);
1547     return ret;
1548 }
1549
1550 int ff_packet_list_get(AVPacketList **pkt_buffer,
1551                        AVPacketList **pkt_buffer_end,
1552                        AVPacket      *pkt)
1553 {
1554     AVPacketList *pktl;
1555     av_assert0(*pkt_buffer);
1556     pktl        = *pkt_buffer;
1557     *pkt        = pktl->pkt;
1558     *pkt_buffer = pktl->next;
1559     if (!pktl->next)
1560         *pkt_buffer_end = NULL;
1561     av_freep(&pktl);
1562     return 0;
1563 }
1564
1565 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1566 {
1567     return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1568 }
1569
1570 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1571 {
1572     int ret = 0, i, got_packet = 0;
1573     AVDictionary *metadata = NULL;
1574
1575     av_init_packet(pkt);
1576
1577     while (!got_packet && !s->internal->parse_queue) {
1578         AVStream *st;
1579         AVPacket cur_pkt;
1580
1581         /* read next packet */
1582         ret = ff_read_packet(s, &cur_pkt);
1583         if (ret < 0) {
1584             if (ret == AVERROR(EAGAIN))
1585                 return ret;
1586             /* flush the parsers */
1587             for (i = 0; i < s->nb_streams; i++) {
1588                 st = s->streams[i];
1589                 if (st->parser && st->need_parsing)
1590                     parse_packet(s, NULL, st->index);
1591             }
1592             /* all remaining packets are now in parse_queue =>
1593              * really terminate parsing */
1594             break;
1595         }
1596         ret = 0;
1597         st  = s->streams[cur_pkt.stream_index];
1598
1599         /* update context if required */
1600         if (st->internal->need_context_update) {
1601             if (avcodec_is_open(st->internal->avctx)) {
1602                 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1603                 avcodec_close(st->internal->avctx);
1604                 st->info->found_decoder = 0;
1605             }
1606
1607             /* close parser, because it depends on the codec */
1608             if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1609                 av_parser_close(st->parser);
1610                 st->parser = NULL;
1611             }
1612
1613             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1614             if (ret < 0)
1615                 return ret;
1616
1617 #if FF_API_LAVF_AVCTX
1618 FF_DISABLE_DEPRECATION_WARNINGS
1619             /* update deprecated public codec context */
1620             ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1621             if (ret < 0)
1622                 return ret;
1623 FF_ENABLE_DEPRECATION_WARNINGS
1624 #endif
1625
1626             st->internal->need_context_update = 0;
1627         }
1628
1629         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1630             cur_pkt.dts != AV_NOPTS_VALUE &&
1631             cur_pkt.pts < cur_pkt.dts) {
1632             av_log(s, AV_LOG_WARNING,
1633                    "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1634                    cur_pkt.stream_index,
1635                    av_ts2str(cur_pkt.pts),
1636                    av_ts2str(cur_pkt.dts),
1637                    cur_pkt.size);
1638         }
1639         if (s->debug & FF_FDEBUG_TS)
1640             av_log(s, AV_LOG_DEBUG,
1641                    "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1642                    cur_pkt.stream_index,
1643                    av_ts2str(cur_pkt.pts),
1644                    av_ts2str(cur_pkt.dts),
1645                    cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1646
1647         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1648             st->parser = av_parser_init(st->codecpar->codec_id);
1649             if (!st->parser) {
1650                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1651                        "%s, packets or times may be invalid.\n",
1652                        avcodec_get_name(st->codecpar->codec_id));
1653                 /* no parser available: just output the raw packets */
1654                 st->need_parsing = AVSTREAM_PARSE_NONE;
1655             } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1656                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1657             else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1658                 st->parser->flags |= PARSER_FLAG_ONCE;
1659             else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1660                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1661         }
1662
1663         if (!st->need_parsing || !st->parser) {
1664             /* no parsing needed: we just output the packet as is */
1665             *pkt = cur_pkt;
1666             compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1667             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1668                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1669                 ff_reduce_index(s, st->index);
1670                 av_add_index_entry(st, pkt->pos, pkt->dts,
1671                                    0, 0, AVINDEX_KEYFRAME);
1672             }
1673             got_packet = 1;
1674         } else if (st->discard < AVDISCARD_ALL) {
1675             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1676                 return ret;
1677             st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1678             st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1679             st->codecpar->channels = st->internal->avctx->channels;
1680             st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1681             st->codecpar->codec_id = st->internal->avctx->codec_id;
1682         } else {
1683             /* free packet */
1684             av_packet_unref(&cur_pkt);
1685         }
1686         if (pkt->flags & AV_PKT_FLAG_KEY)
1687             st->skip_to_keyframe = 0;
1688         if (st->skip_to_keyframe) {
1689             av_packet_unref(&cur_pkt);
1690             if (got_packet) {
1691                 *pkt = cur_pkt;
1692             }
1693             got_packet = 0;
1694         }
1695     }
1696
1697     if (!got_packet && s->internal->parse_queue)
1698         ret = ff_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1699
1700     if (ret >= 0) {
1701         AVStream *st = s->streams[pkt->stream_index];
1702         int discard_padding = 0;
1703         if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1704             int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1705             int64_t sample = ts_to_samples(st, pts);
1706             int duration = ts_to_samples(st, pkt->duration);
1707             int64_t end_sample = sample + duration;
1708             if (duration > 0 && end_sample >= st->first_discard_sample &&
1709                 sample < st->last_discard_sample)
1710                 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1711         }
1712         if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1713             st->skip_samples = st->start_skip_samples;
1714         if (st->skip_samples || discard_padding) {
1715             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1716             if (p) {
1717                 AV_WL32(p, st->skip_samples);
1718                 AV_WL32(p + 4, discard_padding);
1719                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1720             }
1721             st->skip_samples = 0;
1722         }
1723
1724         if (st->inject_global_side_data) {
1725             for (i = 0; i < st->nb_side_data; i++) {
1726                 AVPacketSideData *src_sd = &st->side_data[i];
1727                 uint8_t *dst_data;
1728
1729                 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1730                     continue;
1731
1732                 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1733                 if (!dst_data) {
1734                     av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1735                     continue;
1736                 }
1737
1738                 memcpy(dst_data, src_sd->data, src_sd->size);
1739             }
1740             st->inject_global_side_data = 0;
1741         }
1742     }
1743
1744     av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1745     if (metadata) {
1746         s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1747         av_dict_copy(&s->metadata, metadata, 0);
1748         av_dict_free(&metadata);
1749         av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1750     }
1751
1752 #if FF_API_LAVF_AVCTX
1753     update_stream_avctx(s);
1754 #endif
1755
1756     if (s->debug & FF_FDEBUG_TS)
1757         av_log(s, AV_LOG_DEBUG,
1758                "read_frame_internal stream=%d, pts=%s, dts=%s, "
1759                "size=%d, duration=%"PRId64", flags=%d\n",
1760                pkt->stream_index,
1761                av_ts2str(pkt->pts),
1762                av_ts2str(pkt->dts),
1763                pkt->size, pkt->duration, pkt->flags);
1764
1765     return ret;
1766 }
1767
1768 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1769 {
1770     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1771     int eof = 0;
1772     int ret;
1773     AVStream *st;
1774
1775     if (!genpts) {
1776         ret = s->internal->packet_buffer
1777               ? ff_packet_list_get(&s->internal->packet_buffer,
1778                                         &s->internal->packet_buffer_end, pkt)
1779               : read_frame_internal(s, pkt);
1780         if (ret < 0)
1781             return ret;
1782         goto return_packet;
1783     }
1784
1785     for (;;) {
1786         AVPacketList *pktl = s->internal->packet_buffer;
1787
1788         if (pktl) {
1789             AVPacket *next_pkt = &pktl->pkt;
1790
1791             if (next_pkt->dts != AV_NOPTS_VALUE) {
1792                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1793                 // last dts seen for this stream. if any of packets following
1794                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1795                 int64_t last_dts = next_pkt->dts;
1796                 av_assert2(wrap_bits <= 64);
1797                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1798                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1799                         av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1800                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1801                             // not B-frame
1802                             next_pkt->pts = pktl->pkt.dts;
1803                         }
1804                         if (last_dts != AV_NOPTS_VALUE) {
1805                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1806                             last_dts = pktl->pkt.dts;
1807                         }
1808                     }
1809                     pktl = pktl->next;
1810                 }
1811                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1812                     // Fixing the last reference frame had none pts issue (For MXF etc).
1813                     // We only do this when
1814                     // 1. eof.
1815                     // 2. we are not able to resolve a pts value for current packet.
1816                     // 3. the packets for this stream at the end of the files had valid dts.
1817                     next_pkt->pts = last_dts + next_pkt->duration;
1818                 }
1819                 pktl = s->internal->packet_buffer;
1820             }
1821
1822             /* read packet from packet buffer, if there is data */
1823             st = s->streams[next_pkt->stream_index];
1824             if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1825                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1826                 ret = ff_packet_list_get(&s->internal->packet_buffer,
1827                                                &s->internal->packet_buffer_end, pkt);
1828                 goto return_packet;
1829             }
1830         }
1831
1832         ret = read_frame_internal(s, pkt);
1833         if (ret < 0) {
1834             if (pktl && ret != AVERROR(EAGAIN)) {
1835                 eof = 1;
1836                 continue;
1837             } else
1838                 return ret;
1839         }
1840
1841         ret = ff_packet_list_put(&s->internal->packet_buffer,
1842                                  &s->internal->packet_buffer_end,
1843                                  pkt, FF_PACKETLIST_FLAG_REF_PACKET);
1844         av_packet_unref(pkt);
1845         if (ret < 0)
1846             return ret;
1847     }
1848
1849 return_packet:
1850
1851     st = s->streams[pkt->stream_index];
1852     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1853         ff_reduce_index(s, st->index);
1854         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1855     }
1856
1857     if (is_relative(pkt->dts))
1858         pkt->dts -= RELATIVE_TS_BASE;
1859     if (is_relative(pkt->pts))
1860         pkt->pts -= RELATIVE_TS_BASE;
1861
1862     return ret;
1863 }
1864
1865 /* XXX: suppress the packet queue */
1866 static void flush_packet_queue(AVFormatContext *s)
1867 {
1868     if (!s->internal)
1869         return;
1870     ff_packet_list_free(&s->internal->parse_queue,       &s->internal->parse_queue_end);
1871     ff_packet_list_free(&s->internal->packet_buffer,     &s->internal->packet_buffer_end);
1872     ff_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1873
1874     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1875 }
1876
1877 /*******************************************************/
1878 /* seek support */
1879
1880 int av_find_default_stream_index(AVFormatContext *s)
1881 {
1882     int i;
1883     AVStream *st;
1884     int best_stream = 0;
1885     int best_score = INT_MIN;
1886
1887     if (s->nb_streams <= 0)
1888         return -1;
1889     for (i = 0; i < s->nb_streams; i++) {
1890         int score = 0;
1891         st = s->streams[i];
1892         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1893             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1894                 score -= 400;
1895             if (st->codecpar->width && st->codecpar->height)
1896                 score += 50;
1897             score+= 25;
1898         }
1899         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1900             if (st->codecpar->sample_rate)
1901                 score += 50;
1902         }
1903         if (st->codec_info_nb_frames)
1904             score += 12;
1905
1906         if (st->discard != AVDISCARD_ALL)
1907             score += 200;
1908
1909         if (score > best_score) {
1910             best_score = score;
1911             best_stream = i;
1912         }
1913     }
1914     return best_stream;
1915 }
1916
1917 /** Flush the frame reader. */
1918 void ff_read_frame_flush(AVFormatContext *s)
1919 {
1920     AVStream *st;
1921     int i, j;
1922
1923     flush_packet_queue(s);
1924
1925     /* Reset read state for each stream. */
1926     for (i = 0; i < s->nb_streams; i++) {
1927         st = s->streams[i];
1928
1929         if (st->parser) {
1930             av_parser_close(st->parser);
1931             st->parser = NULL;
1932         }
1933         st->last_IP_pts = AV_NOPTS_VALUE;
1934         st->last_dts_for_order_check = AV_NOPTS_VALUE;
1935         if (st->first_dts == AV_NOPTS_VALUE)
1936             st->cur_dts = RELATIVE_TS_BASE;
1937         else
1938             /* We set the current DTS to an unspecified origin. */
1939             st->cur_dts = AV_NOPTS_VALUE;
1940
1941         st->probe_packets = MAX_PROBE_PACKETS;
1942
1943         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1944             st->pts_buffer[j] = AV_NOPTS_VALUE;
1945
1946         if (s->internal->inject_global_side_data)
1947             st->inject_global_side_data = 1;
1948
1949         st->skip_samples = 0;
1950     }
1951 }
1952
1953 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1954 {
1955     int i;
1956
1957     for (i = 0; i < s->nb_streams; i++) {
1958         AVStream *st = s->streams[i];
1959
1960         st->cur_dts =
1961             av_rescale(timestamp,
1962                        st->time_base.den * (int64_t) ref_st->time_base.num,
1963                        st->time_base.num * (int64_t) ref_st->time_base.den);
1964     }
1965 }
1966
1967 void ff_reduce_index(AVFormatContext *s, int stream_index)
1968 {
1969     AVStream *st             = s->streams[stream_index];
1970     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1971
1972     if ((unsigned) st->nb_index_entries >= max_entries) {
1973         int i;
1974         for (i = 0; 2 * i < st->nb_index_entries; i++)
1975             st->index_entries[i] = st->index_entries[2 * i];
1976         st->nb_index_entries = i;
1977     }
1978 }
1979
1980 int ff_add_index_entry(AVIndexEntry **index_entries,
1981                        int *nb_index_entries,
1982                        unsigned int *index_entries_allocated_size,
1983                        int64_t pos, int64_t timestamp,
1984                        int size, int distance, int flags)
1985 {
1986     AVIndexEntry *entries, *ie;
1987     int index;
1988
1989     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1990         return -1;
1991
1992     if (timestamp == AV_NOPTS_VALUE)
1993         return AVERROR(EINVAL);
1994
1995     if (size < 0 || size > 0x3FFFFFFF)
1996         return AVERROR(EINVAL);
1997
1998     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1999         timestamp -= RELATIVE_TS_BASE;
2000
2001     entries = av_fast_realloc(*index_entries,
2002                               index_entries_allocated_size,
2003                               (*nb_index_entries + 1) *
2004                               sizeof(AVIndexEntry));
2005     if (!entries)
2006         return -1;
2007
2008     *index_entries = entries;
2009
2010     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2011                                       timestamp, AVSEEK_FLAG_ANY);
2012
2013     if (index < 0) {
2014         index = (*nb_index_entries)++;
2015         ie    = &entries[index];
2016         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2017     } else {
2018         ie = &entries[index];
2019         if (ie->timestamp != timestamp) {
2020             if (ie->timestamp <= timestamp)
2021                 return -1;
2022             memmove(entries + index + 1, entries + index,
2023                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
2024             (*nb_index_entries)++;
2025         } else if (ie->pos == pos && distance < ie->min_distance)
2026             // do not reduce the distance
2027             distance = ie->min_distance;
2028     }
2029
2030     ie->pos          = pos;
2031     ie->timestamp    = timestamp;
2032     ie->min_distance = distance;
2033     ie->size         = size;
2034     ie->flags        = flags;
2035
2036     return index;
2037 }
2038
2039 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2040                        int size, int distance, int flags)
2041 {
2042     timestamp = wrap_timestamp(st, timestamp);
2043     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2044                               &st->index_entries_allocated_size, pos,
2045                               timestamp, size, distance, flags);
2046 }
2047
2048 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2049                               int64_t wanted_timestamp, int flags)
2050 {
2051     int a, b, m;
2052     int64_t timestamp;
2053
2054     a = -1;
2055     b = nb_entries;
2056
2057     // Optimize appending index entries at the end.
2058     if (b && entries[b - 1].timestamp < wanted_timestamp)
2059         a = b - 1;
2060
2061     while (b - a > 1) {
2062         m         = (a + b) >> 1;
2063
2064         // Search for the next non-discarded packet.
2065         while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2066             m++;
2067             if (m == b && entries[m].timestamp >= wanted_timestamp) {
2068                 m = b - 1;
2069                 break;
2070             }
2071         }
2072
2073         timestamp = entries[m].timestamp;
2074         if (timestamp >= wanted_timestamp)
2075             b = m;
2076         if (timestamp <= wanted_timestamp)
2077             a = m;
2078     }
2079     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2080
2081     if (!(flags & AVSEEK_FLAG_ANY))
2082         while (m >= 0 && m < nb_entries &&
2083                !(entries[m].flags & AVINDEX_KEYFRAME))
2084             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2085
2086     if (m == nb_entries)
2087         return -1;
2088     return m;
2089 }
2090
2091 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2092 {
2093     int ist1, ist2;
2094     int64_t pos_delta = 0;
2095     int64_t skip = 0;
2096     //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2097     const char *proto = avio_find_protocol_name(s->url);
2098
2099     if (!proto) {
2100         av_log(s, AV_LOG_INFO,
2101                "Protocol name not provided, cannot determine if input is local or "
2102                "a network protocol, buffers and access patterns cannot be configured "
2103                "optimally without knowing the protocol\n");
2104     }
2105
2106     if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2107         return;
2108
2109     for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2110         AVStream *st1 = s->streams[ist1];
2111         for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2112             AVStream *st2 = s->streams[ist2];
2113             int i1, i2;
2114
2115             if (ist1 == ist2)
2116                 continue;
2117
2118             for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2119                 AVIndexEntry *e1 = &st1->index_entries[i1];
2120                 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2121
2122                 skip = FFMAX(skip, e1->size);
2123                 for (; i2 < st2->nb_index_entries; i2++) {
2124                     AVIndexEntry *e2 = &st2->index_entries[i2];
2125                     int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2126                     if (e2_pts - e1_pts < time_tolerance)
2127                         continue;
2128                     pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2129                     break;
2130                 }
2131             }
2132         }
2133     }
2134
2135     pos_delta *= 2;
2136     /* XXX This could be adjusted depending on protocol*/
2137     if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2138         av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2139         ffio_set_buf_size(s->pb, pos_delta);
2140         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2141     }
2142
2143     if (skip < (1<<23)) {
2144         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2145     }
2146 }
2147
2148 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2149 {
2150     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2151                                      wanted_timestamp, flags);
2152 }
2153
2154 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2155                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2156 {
2157     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2158     if (stream_index >= 0)
2159         ts = wrap_timestamp(s->streams[stream_index], ts);
2160     return ts;
2161 }
2162
2163 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2164                          int64_t target_ts, int flags)
2165 {
2166     const AVInputFormat *avif = s->iformat;
2167     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2168     int64_t ts_min, ts_max, ts;
2169     int index;
2170     int64_t ret;
2171     AVStream *st;
2172
2173     if (stream_index < 0)
2174         return -1;
2175
2176     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2177
2178     ts_max =
2179     ts_min = AV_NOPTS_VALUE;
2180     pos_limit = -1; // GCC falsely says it may be uninitialized.
2181
2182     st = s->streams[stream_index];
2183     if (st->index_entries) {
2184         AVIndexEntry *e;
2185
2186         /* FIXME: Whole function must be checked for non-keyframe entries in
2187          * index case, especially read_timestamp(). */
2188         index = av_index_search_timestamp(st, target_ts,
2189                                           flags | AVSEEK_FLAG_BACKWARD);
2190         index = FFMAX(index, 0);
2191         e     = &st->index_entries[index];
2192
2193         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2194             pos_min = e->pos;
2195             ts_min  = e->timestamp;
2196             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2197                     pos_min, av_ts2str(ts_min));
2198         } else {
2199             av_assert1(index == 0);
2200         }
2201
2202         index = av_index_search_timestamp(st, target_ts,
2203                                           flags & ~AVSEEK_FLAG_BACKWARD);
2204         av_assert0(index < st->nb_index_entries);
2205         if (index >= 0) {
2206             e = &st->index_entries[index];
2207             av_assert1(e->timestamp >= target_ts);
2208             pos_max   = e->pos;
2209             ts_max    = e->timestamp;
2210             pos_limit = pos_max - e->min_distance;
2211             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2212                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2213         }
2214     }
2215
2216     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2217                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
2218     if (pos < 0)
2219         return -1;
2220
2221     /* do the seek */
2222     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2223         return ret;
2224
2225     ff_read_frame_flush(s);
2226     ff_update_cur_dts(s, st, ts);
2227
2228     return 0;
2229 }
2230
2231 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2232                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2233 {
2234     int64_t step = 1024;
2235     int64_t limit, ts_max;
2236     int64_t filesize = avio_size(s->pb);
2237     int64_t pos_max  = filesize - 1;
2238     do {
2239         limit = pos_max;
2240         pos_max = FFMAX(0, (pos_max) - step);
2241         ts_max  = ff_read_timestamp(s, stream_index,
2242                                     &pos_max, limit, read_timestamp);
2243         step   += step;
2244     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2245     if (ts_max == AV_NOPTS_VALUE)
2246         return -1;
2247
2248     for (;;) {
2249         int64_t tmp_pos = pos_max + 1;
2250         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
2251                                             &tmp_pos, INT64_MAX, read_timestamp);
2252         if (tmp_ts == AV_NOPTS_VALUE)
2253             break;
2254         av_assert0(tmp_pos > pos_max);
2255         ts_max  = tmp_ts;
2256         pos_max = tmp_pos;
2257         if (tmp_pos >= filesize)
2258             break;
2259     }
2260
2261     if (ts)
2262         *ts = ts_max;
2263     if (pos)
2264         *pos = pos_max;
2265
2266     return 0;
2267 }
2268
2269 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2270                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2271                       int64_t ts_min, int64_t ts_max,
2272                       int flags, int64_t *ts_ret,
2273                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
2274                                                 int64_t *, int64_t))
2275 {
2276     int64_t pos, ts;
2277     int64_t start_pos;
2278     int no_change;
2279     int ret;
2280
2281     av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2282
2283     if (ts_min == AV_NOPTS_VALUE) {
2284         pos_min = s->internal->data_offset;
2285         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2286         if (ts_min == AV_NOPTS_VALUE)
2287             return -1;
2288     }
2289
2290     if (ts_min >= target_ts) {
2291         *ts_ret = ts_min;
2292         return pos_min;
2293     }
2294
2295     if (ts_max == AV_NOPTS_VALUE) {
2296         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2297             return ret;
2298         pos_limit = pos_max;
2299     }
2300
2301     if (ts_max <= target_ts) {
2302         *ts_ret = ts_max;
2303         return pos_max;
2304     }
2305
2306     av_assert0(ts_min < ts_max);
2307
2308     no_change = 0;
2309     while (pos_min < pos_limit) {
2310         av_log(s, AV_LOG_TRACE,
2311                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2312                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2313         av_assert0(pos_limit <= pos_max);
2314
2315         if (no_change == 0) {
2316             int64_t approximate_keyframe_distance = pos_max - pos_limit;
2317             // interpolate position (better than dichotomy)
2318             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2319                              ts_max - ts_min) +
2320                   pos_min - approximate_keyframe_distance;
2321         } else if (no_change == 1) {
2322             // bisection if interpolation did not change min / max pos last time
2323             pos = (pos_min + pos_limit) >> 1;
2324         } else {
2325             /* linear search if bisection failed, can only happen if there
2326              * are very few or no keyframes between min/max */
2327             pos = pos_min;
2328         }
2329         if (pos <= pos_min)
2330             pos = pos_min + 1;
2331         else if (pos > pos_limit)
2332             pos = pos_limit;
2333         start_pos = pos;
2334
2335         // May pass pos_limit instead of -1.
2336         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2337         if (pos == pos_max)
2338             no_change++;
2339         else
2340             no_change = 0;
2341         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2342                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2343                 pos_min, pos, pos_max,
2344                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2345                 pos_limit, start_pos, no_change);
2346         if (ts == AV_NOPTS_VALUE) {
2347             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2348             return -1;
2349         }
2350         if (target_ts <= ts) {
2351             pos_limit = start_pos - 1;
2352             pos_max   = pos;
2353             ts_max    = ts;
2354         }
2355         if (target_ts >= ts) {
2356             pos_min = pos;
2357             ts_min  = ts;
2358         }
2359     }
2360
2361     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2362     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
2363 #if 0
2364     pos_min = pos;
2365     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2366     pos_min++;
2367     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2368     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2369             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2370 #endif
2371     *ts_ret = ts;
2372     return pos;
2373 }
2374
2375 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2376                            int64_t pos, int flags)
2377 {
2378     int64_t pos_min, pos_max;
2379
2380     pos_min = s->internal->data_offset;
2381     pos_max = avio_size(s->pb) - 1;
2382
2383     if (pos < pos_min)
2384         pos = pos_min;
2385     else if (pos > pos_max)
2386         pos = pos_max;
2387
2388     avio_seek(s->pb, pos, SEEK_SET);
2389
2390     s->io_repositioned = 1;
2391
2392     return 0;
2393 }
2394
2395 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2396                               int64_t timestamp, int flags)
2397 {
2398     int index;
2399     int64_t ret;
2400     AVStream *st;
2401     AVIndexEntry *ie;
2402
2403     st = s->streams[stream_index];
2404
2405     index = av_index_search_timestamp(st, timestamp, flags);
2406
2407     if (index < 0 && st->nb_index_entries &&
2408         timestamp < st->index_entries[0].timestamp)
2409         return -1;
2410
2411     if (index < 0 || index == st->nb_index_entries - 1) {
2412         AVPacket pkt;
2413         int nonkey = 0;
2414
2415         if (st->nb_index_entries) {
2416             av_assert0(st->index_entries);
2417             ie = &st->index_entries[st->nb_index_entries - 1];
2418             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2419                 return ret;
2420             ff_update_cur_dts(s, st, ie->timestamp);
2421         } else {
2422             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2423                 return ret;
2424         }
2425         for (;;) {
2426             int read_status;
2427             do {
2428                 read_status = av_read_frame(s, &pkt);
2429             } while (read_status == AVERROR(EAGAIN));
2430             if (read_status < 0)
2431                 break;
2432             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2433                 if (pkt.flags & AV_PKT_FLAG_KEY) {
2434                     av_packet_unref(&pkt);
2435                     break;
2436                 }
2437                 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2438                     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);
2439                     av_packet_unref(&pkt);
2440                     break;
2441                 }
2442             }
2443             av_packet_unref(&pkt);
2444         }
2445         index = av_index_search_timestamp(st, timestamp, flags);
2446     }
2447     if (index < 0)
2448         return -1;
2449
2450     ff_read_frame_flush(s);
2451     if (s->iformat->read_seek)
2452         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2453             return 0;
2454     ie = &st->index_entries[index];
2455     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2456         return ret;
2457     ff_update_cur_dts(s, st, ie->timestamp);
2458
2459     return 0;
2460 }
2461
2462 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2463                                int64_t timestamp, int flags)
2464 {
2465     int ret;
2466     AVStream *st;
2467
2468     if (flags & AVSEEK_FLAG_BYTE) {
2469         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2470             return -1;
2471         ff_read_frame_flush(s);
2472         return seek_frame_byte(s, stream_index, timestamp, flags);
2473     }
2474
2475     if (stream_index < 0) {
2476         stream_index = av_find_default_stream_index(s);
2477         if (stream_index < 0)
2478             return -1;
2479
2480         st = s->streams[stream_index];
2481         /* timestamp for default must be expressed in AV_TIME_BASE units */
2482         timestamp = av_rescale(timestamp, st->time_base.den,
2483                                AV_TIME_BASE * (int64_t) st->time_base.num);
2484     }
2485
2486     /* first, we try the format specific seek */
2487     if (s->iformat->read_seek) {
2488         ff_read_frame_flush(s);
2489         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2490     } else
2491         ret = -1;
2492     if (ret >= 0)
2493         return 0;
2494
2495     if (s->iformat->read_timestamp &&
2496         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2497         ff_read_frame_flush(s);
2498         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2499     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2500         ff_read_frame_flush(s);
2501         return seek_frame_generic(s, stream_index, timestamp, flags);
2502     } else
2503         return -1;
2504 }
2505
2506 int av_seek_frame(AVFormatContext *s, int stream_index,
2507                   int64_t timestamp, int flags)
2508 {
2509     int ret;
2510
2511     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2512         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2513         if ((flags & AVSEEK_FLAG_BACKWARD))
2514             max_ts = timestamp;
2515         else
2516             min_ts = timestamp;
2517         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2518                                   flags & ~AVSEEK_FLAG_BACKWARD);
2519     }
2520
2521     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2522
2523     if (ret >= 0)
2524         ret = avformat_queue_attached_pictures(s);
2525
2526     return ret;
2527 }
2528
2529 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2530                        int64_t ts, int64_t max_ts, int flags)
2531 {
2532     if (min_ts > ts || max_ts < ts)
2533         return -1;
2534     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2535         return AVERROR(EINVAL);
2536
2537     if (s->seek2any>0)
2538         flags |= AVSEEK_FLAG_ANY;
2539     flags &= ~AVSEEK_FLAG_BACKWARD;
2540
2541     if (s->iformat->read_seek2) {
2542         int ret;
2543         ff_read_frame_flush(s);
2544
2545         if (stream_index == -1 && s->nb_streams == 1) {
2546             AVRational time_base = s->streams[0]->time_base;
2547             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2548             min_ts = av_rescale_rnd(min_ts, time_base.den,
2549                                     time_base.num * (int64_t)AV_TIME_BASE,
2550                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2551             max_ts = av_rescale_rnd(max_ts, time_base.den,
2552                                     time_base.num * (int64_t)AV_TIME_BASE,
2553                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2554             stream_index = 0;
2555         }
2556
2557         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2558                                      ts, max_ts, flags);
2559
2560         if (ret >= 0)
2561             ret = avformat_queue_attached_pictures(s);
2562         return ret;
2563     }
2564
2565     if (s->iformat->read_timestamp) {
2566         // try to seek via read_timestamp()
2567     }
2568
2569     // Fall back on old API if new is not implemented but old is.
2570     // Note the old API has somewhat different semantics.
2571     if (s->iformat->read_seek || 1) {
2572         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2573         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2574         if (ret<0 && ts != min_ts && max_ts != ts) {
2575             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2576             if (ret >= 0)
2577                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2578         }
2579         return ret;
2580     }
2581
2582     // try some generic seek like seek_frame_generic() but with new ts semantics
2583     return -1; //unreachable
2584 }
2585
2586 int avformat_flush(AVFormatContext *s)
2587 {
2588     ff_read_frame_flush(s);
2589     return 0;
2590 }
2591
2592 /*******************************************************/
2593
2594 /**
2595  * Return TRUE if the stream has accurate duration in any stream.
2596  *
2597  * @return TRUE if the stream has accurate duration for at least one component.
2598  */
2599 static int has_duration(AVFormatContext *ic)
2600 {
2601     int i;
2602     AVStream *st;
2603
2604     for (i = 0; i < ic->nb_streams; i++) {
2605         st = ic->streams[i];
2606         if (st->duration != AV_NOPTS_VALUE)
2607             return 1;
2608     }
2609     if (ic->duration != AV_NOPTS_VALUE)
2610         return 1;
2611     return 0;
2612 }
2613
2614 /**
2615  * Estimate the stream timings from the one of each components.
2616  *
2617  * Also computes the global bitrate if possible.
2618  */
2619 static void update_stream_timings(AVFormatContext *ic)
2620 {
2621     int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2622     int64_t duration, duration1, duration_text, filesize;
2623     int i;
2624     AVProgram *p;
2625
2626     start_time = INT64_MAX;
2627     start_time_text = INT64_MAX;
2628     end_time   = INT64_MIN;
2629     end_time_text   = INT64_MIN;
2630     duration   = INT64_MIN;
2631     duration_text = INT64_MIN;
2632
2633     for (i = 0; i < ic->nb_streams; i++) {
2634         AVStream *st = ic->streams[i];
2635         int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
2636                       st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
2637         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2638             start_time1 = av_rescale_q(st->start_time, st->time_base,
2639                                        AV_TIME_BASE_Q);
2640             if (is_text)
2641                 start_time_text = FFMIN(start_time_text, start_time1);
2642             else
2643                 start_time = FFMIN(start_time, start_time1);
2644             end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2645                                          AV_TIME_BASE_Q,
2646                                          AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2647             if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2648                 end_time1 += start_time1;
2649                 if (is_text)
2650                     end_time_text = FFMAX(end_time_text, end_time1);
2651                 else
2652                     end_time = FFMAX(end_time, end_time1);
2653             }
2654             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2655                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2656                     p->start_time = start_time1;
2657                 if (p->end_time < end_time1)
2658                     p->end_time = end_time1;
2659             }
2660         }
2661         if (st->duration != AV_NOPTS_VALUE) {
2662             duration1 = av_rescale_q(st->duration, st->time_base,
2663                                      AV_TIME_BASE_Q);
2664             if (is_text)
2665                 duration_text = FFMAX(duration_text, duration1);
2666             else
2667                 duration = FFMAX(duration, duration1);
2668         }
2669     }
2670     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
2671         start_time = start_time_text;
2672     else if (start_time > start_time_text)
2673         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2674
2675     if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
2676         end_time = end_time_text;
2677     else if (end_time < end_time_text)
2678         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2679
2680      if (duration == INT64_MIN || (duration < duration_text && duration_text - duration < AV_TIME_BASE))
2681          duration = duration_text;
2682      else if (duration < duration_text)
2683          av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE);
2684
2685     if (start_time != INT64_MAX) {
2686         ic->start_time = start_time;
2687         if (end_time != INT64_MIN) {
2688             if (ic->nb_programs > 1) {
2689                 for (i = 0; i < ic->nb_programs; i++) {
2690                     p = ic->programs[i];
2691                     if (p->start_time != AV_NOPTS_VALUE &&
2692                         p->end_time > p->start_time &&
2693                         p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2694                         duration = FFMAX(duration, p->end_time - p->start_time);
2695                 }
2696             } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2697                 duration = FFMAX(duration, end_time - start_time);
2698             }
2699         }
2700     }
2701     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2702         ic->duration = duration;
2703     }
2704     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2705         /* compute the bitrate */
2706         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2707                          (double) ic->duration;
2708         if (bitrate >= 0 && bitrate <= INT64_MAX)
2709             ic->bit_rate = bitrate;
2710     }
2711 }
2712
2713 static void fill_all_stream_timings(AVFormatContext *ic)
2714 {
2715     int i;
2716     AVStream *st;
2717
2718     update_stream_timings(ic);
2719     for (i = 0; i < ic->nb_streams; i++) {
2720         st = ic->streams[i];
2721         if (st->start_time == AV_NOPTS_VALUE) {
2722             if (ic->start_time != AV_NOPTS_VALUE)
2723                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2724                                               st->time_base);
2725             if (ic->duration != AV_NOPTS_VALUE)
2726                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2727                                             st->time_base);
2728         }
2729     }
2730 }
2731
2732 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2733 {
2734     int64_t filesize, duration;
2735     int i, show_warning = 0;
2736     AVStream *st;
2737
2738     /* if bit_rate is already set, we believe it */
2739     if (ic->bit_rate <= 0) {
2740         int64_t bit_rate = 0;
2741         for (i = 0; i < ic->nb_streams; i++) {
2742             st = ic->streams[i];
2743             if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2744                 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2745             if (st->codecpar->bit_rate > 0) {
2746                 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2747                     bit_rate = 0;
2748                     break;
2749                 }
2750                 bit_rate += st->codecpar->bit_rate;
2751             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2752                 // If we have a videostream with packets but without a bitrate
2753                 // then consider the sum not known
2754                 bit_rate = 0;
2755                 break;
2756             }
2757         }
2758         ic->bit_rate = bit_rate;
2759     }
2760
2761     /* if duration is already set, we believe it */
2762     if (ic->duration == AV_NOPTS_VALUE &&
2763         ic->bit_rate != 0) {
2764         filesize = ic->pb ? avio_size(ic->pb) : 0;
2765         if (filesize > ic->internal->data_offset) {
2766             filesize -= ic->internal->data_offset;
2767             for (i = 0; i < ic->nb_streams; i++) {
2768                 st      = ic->streams[i];
2769                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2770                     && st->duration == AV_NOPTS_VALUE) {
2771                     duration = av_rescale(8 * filesize, st->time_base.den,
2772                                           ic->bit_rate *
2773                                           (int64_t) st->time_base.num);
2774                     st->duration = duration;
2775                     show_warning = 1;
2776                 }
2777             }
2778         }
2779     }
2780     if (show_warning)
2781         av_log(ic, AV_LOG_WARNING,
2782                "Estimating duration from bitrate, this may be inaccurate\n");
2783 }
2784
2785 #define DURATION_MAX_READ_SIZE 250000LL
2786 #define DURATION_MAX_RETRY 6
2787
2788 /* only usable for MPEG-PS streams */
2789 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2790 {
2791     AVPacket pkt1, *pkt = &pkt1;
2792     AVStream *st;
2793     int num, den, read_size, i, ret;
2794     int found_duration = 0;
2795     int is_end;
2796     int64_t filesize, offset, duration;
2797     int retry = 0;
2798
2799     /* flush packet queue */
2800     flush_packet_queue(ic);
2801
2802     for (i = 0; i < ic->nb_streams; i++) {
2803         st = ic->streams[i];
2804         if (st->start_time == AV_NOPTS_VALUE &&
2805             st->first_dts == AV_NOPTS_VALUE &&
2806             st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2807             av_log(ic, AV_LOG_WARNING,
2808                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2809
2810         if (st->parser) {
2811             av_parser_close(st->parser);
2812             st->parser = NULL;
2813         }
2814     }
2815
2816     if (ic->skip_estimate_duration_from_pts) {
2817         av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n");
2818         goto skip_duration_calc;
2819     }
2820
2821     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2822     /* estimate the end time (duration) */
2823     /* XXX: may need to support wrapping */
2824     filesize = ic->pb ? avio_size(ic->pb) : 0;
2825     do {
2826         is_end = found_duration;
2827         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2828         if (offset < 0)
2829             offset = 0;
2830
2831         avio_seek(ic->pb, offset, SEEK_SET);
2832         read_size = 0;
2833         for (;;) {
2834             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2835                 break;
2836
2837             do {
2838                 ret = ff_read_packet(ic, pkt);
2839             } while (ret == AVERROR(EAGAIN));
2840             if (ret != 0)
2841                 break;
2842             read_size += pkt->size;
2843             st         = ic->streams[pkt->stream_index];
2844             if (pkt->pts != AV_NOPTS_VALUE &&
2845                 (st->start_time != AV_NOPTS_VALUE ||
2846                  st->first_dts  != AV_NOPTS_VALUE)) {
2847                 if (pkt->duration == 0) {
2848                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2849                     if (den && num) {
2850                         pkt->duration = av_rescale_rnd(1,
2851                                            num * (int64_t) st->time_base.den,
2852                                            den * (int64_t) st->time_base.num,
2853                                            AV_ROUND_DOWN);
2854                     }
2855                 }
2856                 duration = pkt->pts + pkt->duration;
2857                 found_duration = 1;
2858                 if (st->start_time != AV_NOPTS_VALUE)
2859                     duration -= st->start_time;
2860                 else
2861                     duration -= st->first_dts;
2862                 if (duration > 0) {
2863                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2864                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2865                         st->duration = duration;
2866                     st->info->last_duration = duration;
2867                 }
2868             }
2869             av_packet_unref(pkt);
2870         }
2871
2872         /* check if all audio/video streams have valid duration */
2873         if (!is_end) {
2874             is_end = 1;
2875             for (i = 0; i < ic->nb_streams; i++) {
2876                 st = ic->streams[i];
2877                 switch (st->codecpar->codec_type) {
2878                     case AVMEDIA_TYPE_VIDEO:
2879                     case AVMEDIA_TYPE_AUDIO:
2880                         if (st->duration == AV_NOPTS_VALUE)
2881                             is_end = 0;
2882                 }
2883             }
2884         }
2885     } while (!is_end &&
2886              offset &&
2887              ++retry <= DURATION_MAX_RETRY);
2888
2889     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2890
2891     /* warn about audio/video streams which duration could not be estimated */
2892     for (i = 0; i < ic->nb_streams; i++) {
2893         st = ic->streams[i];
2894         if (st->duration == AV_NOPTS_VALUE) {
2895             switch (st->codecpar->codec_type) {
2896             case AVMEDIA_TYPE_VIDEO:
2897             case AVMEDIA_TYPE_AUDIO:
2898                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2899                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2900                 } else
2901                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2902             }
2903         }
2904     }
2905 skip_duration_calc:
2906     fill_all_stream_timings(ic);
2907
2908     avio_seek(ic->pb, old_offset, SEEK_SET);
2909     for (i = 0; i < ic->nb_streams; i++) {
2910         int j;
2911
2912         st              = ic->streams[i];
2913         st->cur_dts     = st->first_dts;
2914         st->last_IP_pts = AV_NOPTS_VALUE;
2915         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2916         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2917             st->pts_buffer[j] = AV_NOPTS_VALUE;
2918     }
2919 }
2920
2921 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2922 {
2923     int64_t file_size;
2924
2925     /* get the file size, if possible */
2926     if (ic->iformat->flags & AVFMT_NOFILE) {
2927         file_size = 0;
2928     } else {
2929         file_size = avio_size(ic->pb);
2930         file_size = FFMAX(0, file_size);
2931     }
2932
2933     if ((!strcmp(ic->iformat->name, "mpeg") ||
2934          !strcmp(ic->iformat->name, "mpegts")) &&
2935         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2936         /* get accurate estimate from the PTSes */
2937         estimate_timings_from_pts(ic, old_offset);
2938         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2939     } else if (has_duration(ic)) {
2940         /* at least one component has timings - we use them for all
2941          * the components */
2942         fill_all_stream_timings(ic);
2943         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2944     } else {
2945         /* less precise: use bitrate info */
2946         estimate_timings_from_bit_rate(ic);
2947         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2948     }
2949     update_stream_timings(ic);
2950
2951     {
2952         int i;
2953         AVStream av_unused *st;
2954         for (i = 0; i < ic->nb_streams; i++) {
2955             st = ic->streams[i];
2956             if (st->time_base.den)
2957             av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2958                    (double) st->start_time * av_q2d(st->time_base),
2959                    (double) st->duration   * av_q2d(st->time_base));
2960         }
2961         av_log(ic, AV_LOG_TRACE,
2962                 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2963                 (double) ic->start_time / AV_TIME_BASE,
2964                 (double) ic->duration   / AV_TIME_BASE,
2965                 (int64_t)ic->bit_rate / 1000);
2966     }
2967 }
2968
2969 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2970 {
2971     AVCodecContext *avctx = st->internal->avctx;
2972
2973 #define FAIL(errmsg) do {                                         \
2974         if (errmsg_ptr)                                           \
2975             *errmsg_ptr = errmsg;                                 \
2976         return 0;                                                 \
2977     } while (0)
2978
2979     if (   avctx->codec_id == AV_CODEC_ID_NONE
2980         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2981         FAIL("unknown codec");
2982     switch (avctx->codec_type) {
2983     case AVMEDIA_TYPE_AUDIO:
2984         if (!avctx->frame_size && determinable_frame_size(avctx))
2985             FAIL("unspecified frame size");
2986         if (st->info->found_decoder >= 0 &&
2987             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2988             FAIL("unspecified sample format");
2989         if (!avctx->sample_rate)
2990             FAIL("unspecified sample rate");
2991         if (!avctx->channels)
2992             FAIL("unspecified number of channels");
2993         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2994             FAIL("no decodable DTS frames");
2995         break;
2996     case AVMEDIA_TYPE_VIDEO:
2997         if (!avctx->width)
2998             FAIL("unspecified size");
2999         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
3000             FAIL("unspecified pixel format");
3001         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
3002             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
3003                 FAIL("no frame in rv30/40 and no sar");
3004         break;
3005     case AVMEDIA_TYPE_SUBTITLE:
3006         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
3007             FAIL("unspecified size");
3008         break;
3009     case AVMEDIA_TYPE_DATA:
3010         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
3011     }
3012
3013     return 1;
3014 }
3015
3016 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3017 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
3018                             AVDictionary **options)
3019 {
3020     AVCodecContext *avctx = st->internal->avctx;
3021     const AVCodec *codec;
3022     int got_picture = 1, ret = 0;
3023     AVFrame *frame = av_frame_alloc();
3024     AVSubtitle subtitle;
3025     AVPacket pkt = *avpkt;
3026     int do_skip_frame = 0;
3027     enum AVDiscard skip_frame;
3028
3029     if (!frame)
3030         return AVERROR(ENOMEM);
3031
3032     if (!avcodec_is_open(avctx) &&
3033         st->info->found_decoder <= 0 &&
3034         (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3035         AVDictionary *thread_opt = NULL;
3036
3037         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3038
3039         if (!codec) {
3040             st->info->found_decoder = -st->codecpar->codec_id;
3041             ret                     = -1;
3042             goto fail;
3043         }
3044
3045         /* Force thread count to 1 since the H.264 decoder will not extract
3046          * SPS and PPS to extradata during multi-threaded decoding. */
3047         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3048         if (s->codec_whitelist)
3049             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3050         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3051         if (!options)
3052             av_dict_free(&thread_opt);
3053         if (ret < 0) {
3054             st->info->found_decoder = -avctx->codec_id;
3055             goto fail;
3056         }
3057         st->info->found_decoder = 1;
3058     } else if (!st->info->found_decoder)
3059         st->info->found_decoder = 1;
3060
3061     if (st->info->found_decoder < 0) {
3062         ret = -1;
3063         goto fail;
3064     }
3065
3066     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3067         do_skip_frame = 1;
3068         skip_frame = avctx->skip_frame;
3069         avctx->skip_frame = AVDISCARD_ALL;
3070     }
3071
3072     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3073            ret >= 0 &&
3074            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3075             (!st->codec_info_nb_frames &&
3076              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3077         got_picture = 0;
3078         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3079             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3080             ret = avcodec_send_packet(avctx, &pkt);
3081             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3082                 break;
3083             if (ret >= 0)
3084                 pkt.size = 0;
3085             ret = avcodec_receive_frame(avctx, frame);
3086             if (ret >= 0)
3087                 got_picture = 1;
3088             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3089                 ret = 0;
3090         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3091             ret = avcodec_decode_subtitle2(avctx, &subtitle,
3092                                            &got_picture, &pkt);
3093             if (ret >= 0)
3094                 pkt.size = 0;
3095         }
3096         if (ret >= 0) {
3097             if (got_picture)
3098                 st->nb_decoded_frames++;
3099             ret       = got_picture;
3100         }
3101     }
3102
3103     if (!pkt.data && !got_picture)
3104         ret = -1;
3105
3106 fail:
3107     if (do_skip_frame) {
3108         avctx->skip_frame = skip_frame;
3109     }
3110
3111     av_frame_free(&frame);
3112     return ret;
3113 }
3114
3115 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3116 {
3117     while (tags->id != AV_CODEC_ID_NONE) {
3118         if (tags->id == id)
3119             return tags->tag;
3120         tags++;
3121     }
3122     return 0;
3123 }
3124
3125 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3126 {
3127     int i;
3128     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3129         if (tag == tags[i].tag)
3130             return tags[i].id;
3131     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3132         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3133             return tags[i].id;
3134     return AV_CODEC_ID_NONE;
3135 }
3136
3137 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3138 {
3139     if (bps <= 0 || bps > 64)
3140         return AV_CODEC_ID_NONE;
3141
3142     if (flt) {
3143         switch (bps) {
3144         case 32:
3145             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3146         case 64:
3147             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3148         default:
3149             return AV_CODEC_ID_NONE;
3150         }
3151     } else {
3152         bps  += 7;
3153         bps >>= 3;
3154         if (sflags & (1 << (bps - 1))) {
3155             switch (bps) {
3156             case 1:
3157                 return AV_CODEC_ID_PCM_S8;
3158             case 2:
3159                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3160             case 3:
3161                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3162             case 4:
3163                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3164             case 8:
3165                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3166             default:
3167                 return AV_CODEC_ID_NONE;
3168             }
3169         } else {
3170             switch (bps) {
3171             case 1:
3172                 return AV_CODEC_ID_PCM_U8;
3173             case 2:
3174                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3175             case 3:
3176                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3177             case 4:
3178                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3179             default:
3180                 return AV_CODEC_ID_NONE;
3181             }
3182         }
3183     }
3184 }
3185
3186 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3187 {
3188     unsigned int tag;
3189     if (!av_codec_get_tag2(tags, id, &tag))
3190         return 0;
3191     return tag;
3192 }
3193
3194 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3195                       unsigned int *tag)
3196 {
3197     int i;
3198     for (i = 0; tags && tags[i]; i++) {
3199         const AVCodecTag *codec_tags = tags[i];
3200         while (codec_tags->id != AV_CODEC_ID_NONE) {
3201             if (codec_tags->id == id) {
3202                 *tag = codec_tags->tag;
3203                 return 1;
3204             }
3205             codec_tags++;
3206         }
3207     }
3208     return 0;
3209 }
3210
3211 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3212 {
3213     int i;
3214     for (i = 0; tags && tags[i]; i++) {
3215         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3216         if (id != AV_CODEC_ID_NONE)
3217             return id;
3218     }
3219     return AV_CODEC_ID_NONE;
3220 }
3221
3222 static void compute_chapters_end(AVFormatContext *s)
3223 {
3224     unsigned int i, j;
3225     int64_t max_time = 0;
3226
3227     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3228         max_time = s->duration +
3229                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3230
3231     for (i = 0; i < s->nb_chapters; i++)
3232         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3233             AVChapter *ch = s->chapters[i];
3234             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3235                                                   ch->time_base)
3236                                    : INT64_MAX;
3237
3238             for (j = 0; j < s->nb_chapters; j++) {
3239                 AVChapter *ch1     = s->chapters[j];
3240                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3241                                                   ch->time_base);
3242                 if (j != i && next_start > ch->start && next_start < end)
3243                     end = next_start;
3244             }
3245             ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3246         }
3247 }
3248
3249 static int get_std_framerate(int i)
3250 {
3251     if (i < 30*12)
3252         return (i + 1) * 1001;
3253     i -= 30*12;
3254
3255     if (i < 30)
3256         return (i + 31) * 1001 * 12;
3257     i -= 30;
3258
3259     if (i < 3)
3260         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3261
3262     i -= 3;
3263
3264     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3265 }
3266
3267 /* Is the time base unreliable?
3268  * This is a heuristic to balance between quick acceptance of the values in
3269  * the headers vs. some extra checks.
3270  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3271  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3272  * And there are "variable" fps files this needs to detect as well. */
3273 static int tb_unreliable(AVCodecContext *c)
3274 {
3275     if (c->time_base.den >= 101LL * c->time_base.num ||
3276         c->time_base.den <    5LL * c->time_base.num ||
3277         // c->codec_tag == AV_RL32("DIVX") ||
3278         // c->codec_tag == AV_RL32("XVID") ||
3279         c->codec_tag == AV_RL32("mp4v") ||
3280         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3281         c->codec_id == AV_CODEC_ID_GIF ||
3282         c->codec_id == AV_CODEC_ID_HEVC ||
3283         c->codec_id == AV_CODEC_ID_H264)
3284         return 1;
3285     return 0;
3286 }
3287
3288 int ff_alloc_extradata(AVCodecParameters *par, int size)
3289 {
3290     av_freep(&par->extradata);
3291     par->extradata_size = 0;
3292
3293     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3294         return AVERROR(EINVAL);
3295
3296     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3297     if (!par->extradata)
3298         return AVERROR(ENOMEM);
3299
3300     memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3301     par->extradata_size = size;
3302
3303     return 0;
3304 }
3305
3306 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3307 {
3308     int ret = ff_alloc_extradata(par, size);
3309     if (ret < 0)
3310         return ret;
3311     ret = avio_read(pb, par->extradata, size);
3312     if (ret != size) {
3313         av_freep(&par->extradata);
3314         par->extradata_size = 0;
3315         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3316         return ret < 0 ? ret : AVERROR_INVALIDDATA;
3317     }
3318
3319     return ret;
3320 }
3321
3322 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3323 {
3324     int i, j;
3325     int64_t last = st->info->last_dts;
3326
3327     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3328        && ts - (uint64_t)last < INT64_MAX) {
3329         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3330         int64_t duration = ts - last;
3331
3332         if (!st->info->duration_error)
3333             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3334         if (!st->info->duration_error)
3335             return AVERROR(ENOMEM);
3336
3337 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3338 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3339         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3340             if (st->info->duration_error[0][1][i] < 1e10) {
3341                 int framerate = get_std_framerate(i);
3342                 double sdts = dts*framerate/(1001*12);
3343                 for (j= 0; j<2; j++) {
3344                     int64_t ticks = llrint(sdts+j*0.5);
3345                     double error= sdts - ticks + j*0.5;
3346                     st->info->duration_error[j][0][i] += error;
3347                     st->info->duration_error[j][1][i] += error*error;
3348                 }
3349             }
3350         }
3351         if (st->info->rfps_duration_sum <= INT64_MAX - duration) {
3352             st->info->duration_count++;
3353             st->info->rfps_duration_sum += duration;
3354         }
3355
3356         if (st->info->duration_count % 10 == 0) {
3357             int n = st->info->duration_count;
3358             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3359                 if (st->info->duration_error[0][1][i] < 1e10) {
3360                     double a0     = st->info->duration_error[0][0][i] / n;
3361                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3362                     double a1     = st->info->duration_error[1][0][i] / n;
3363                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3364                     if (error0 > 0.04 && error1 > 0.04) {
3365                         st->info->duration_error[0][1][i] = 2e10;
3366                         st->info->duration_error[1][1][i] = 2e10;
3367                     }
3368                 }
3369             }
3370         }
3371
3372         // ignore the first 4 values, they might have some random jitter
3373         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3374             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3375     }
3376     if (ts != AV_NOPTS_VALUE)
3377         st->info->last_dts = ts;
3378
3379     return 0;
3380 }
3381
3382 void ff_rfps_calculate(AVFormatContext *ic)
3383 {
3384     int i, j;
3385
3386     for (i = 0; i < ic->nb_streams; i++) {
3387         AVStream *st = ic->streams[i];
3388
3389         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3390             continue;
3391         // the check for tb_unreliable() is not completely correct, since this is not about handling
3392         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3393         // ipmovie.c produces.
3394         if (tb_unreliable(st->internal->avctx) && 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)
3395             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);
3396         if (st->info->duration_count>1 && !st->r_frame_rate.num
3397             && tb_unreliable(st->internal->avctx)) {
3398             int num = 0;
3399             double best_error= 0.01;
3400             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3401
3402             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3403                 int k;
3404
3405                 if (st->info->codec_info_duration &&
3406                     st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3407                     continue;
3408                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3409                     continue;
3410
3411                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3412                     continue;
3413
3414                 for (k= 0; k<2; k++) {
3415                     int n = st->info->duration_count;
3416                     double a= st->info->duration_error[k][0][j] / n;
3417                     double error= st->info->duration_error[k][1][j]/n - a*a;
3418
3419                     if (error < best_error && best_error> 0.000000001) {
3420                         best_error= error;
3421                         num = get_std_framerate(j);
3422                     }
3423                     if (error < 0.02)
3424                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3425                 }
3426             }
3427             // do not increase frame rate by more than 1 % in order to match a standard rate.
3428             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3429                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3430         }
3431         if (   !st->avg_frame_rate.num
3432             && st->r_frame_rate.num && st->info->rfps_duration_sum
3433             && st->info->codec_info_duration <= 0
3434             && st->info->duration_count > 2
3435             && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
3436             ) {
3437             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3438             st->avg_frame_rate = st->r_frame_rate;
3439         }
3440
3441         av_freep(&st->info->duration_error);
3442         st->info->last_dts = AV_NOPTS_VALUE;
3443         st->info->duration_count = 0;
3444         st->info->rfps_duration_sum = 0;
3445     }
3446 }
3447
3448 static int extract_extradata_check(AVStream *st)
3449 {
3450     const AVBitStreamFilter *f;
3451
3452     f = av_bsf_get_by_name("extract_extradata");
3453     if (!f)
3454         return 0;
3455
3456     if (f->codec_ids) {
3457         const enum AVCodecID *ids;
3458         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3459             if (*ids == st->codecpar->codec_id)
3460                 return 1;
3461     }
3462
3463     return 0;
3464 }
3465
3466 static int extract_extradata_init(AVStream *st)
3467 {
3468     AVStreamInternal *sti = st->internal;
3469     const AVBitStreamFilter *f;
3470     int ret;
3471
3472     f = av_bsf_get_by_name("extract_extradata");
3473     if (!f)
3474         goto finish;
3475
3476     /* check that the codec id is supported */
3477     ret = extract_extradata_check(st);
3478     if (!ret)
3479         goto finish;
3480
3481     sti->extract_extradata.pkt = av_packet_alloc();
3482     if (!sti->extract_extradata.pkt)
3483         return AVERROR(ENOMEM);
3484
3485     ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
3486     if (ret < 0)
3487         goto fail;
3488
3489     ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
3490                                   st->codecpar);
3491     if (ret < 0)
3492         goto fail;
3493
3494     sti->extract_extradata.bsf->time_base_in = st->time_base;
3495
3496     ret = av_bsf_init(sti->extract_extradata.bsf);
3497     if (ret < 0)
3498         goto fail;
3499
3500 finish:
3501     sti->extract_extradata.inited = 1;
3502
3503     return 0;
3504 fail:
3505     av_bsf_free(&sti->extract_extradata.bsf);
3506     av_packet_free(&sti->extract_extradata.pkt);
3507     return ret;
3508 }
3509
3510 static int extract_extradata(AVStream *st, AVPacket *pkt)
3511 {
3512     AVStreamInternal *sti = st->internal;
3513     AVPacket *pkt_ref;
3514     int ret;
3515
3516     if (!sti->extract_extradata.inited) {
3517         ret = extract_extradata_init(st);
3518         if (ret < 0)
3519             return ret;
3520     }
3521
3522     if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
3523         return 0;
3524
3525     pkt_ref = sti->extract_extradata.pkt;
3526     ret = av_packet_ref(pkt_ref, pkt);
3527     if (ret < 0)
3528         return ret;
3529
3530     ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
3531     if (ret < 0) {
3532         av_packet_unref(pkt_ref);
3533         return ret;
3534     }
3535
3536     while (ret >= 0 && !sti->avctx->extradata) {
3537         int extradata_size;
3538         uint8_t *extradata;
3539
3540         ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3541         if (ret < 0) {
3542             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3543                 return ret;
3544             continue;
3545         }
3546
3547         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3548                                             &extradata_size);
3549
3550         if (extradata) {
3551             av_assert0(!sti->avctx->extradata);
3552             if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3553                 sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3554             if (!sti->avctx->extradata) {
3555                 av_packet_unref(pkt_ref);
3556                 return AVERROR(ENOMEM);
3557             }
3558             memcpy(sti->avctx->extradata, extradata, extradata_size);
3559             sti->avctx->extradata_size = extradata_size;
3560         }
3561         av_packet_unref(pkt_ref);
3562     }
3563
3564     return 0;
3565 }
3566
3567 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3568 {
3569     int i, count = 0, ret = 0, j;
3570     int64_t read_size;
3571     AVStream *st;
3572     AVCodecContext *avctx;
3573     AVPacket pkt1, *pkt;
3574     int64_t old_offset  = avio_tell(ic->pb);
3575     // new streams might appear, no options for those
3576     int orig_nb_streams = ic->nb_streams;
3577     int flush_codecs;
3578     int64_t max_analyze_duration = ic->max_analyze_duration;
3579     int64_t max_stream_analyze_duration;
3580     int64_t max_subtitle_analyze_duration;
3581     int64_t probesize = ic->probesize;
3582     int eof_reached = 0;
3583     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3584
3585     flush_codecs = probesize > 0;
3586
3587     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3588
3589     max_stream_analyze_duration = max_analyze_duration;
3590     max_subtitle_analyze_duration = max_analyze_duration;
3591     if (!max_analyze_duration) {
3592         max_stream_analyze_duration =
3593         max_analyze_duration        = 5*AV_TIME_BASE;
3594         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3595         if (!strcmp(ic->iformat->name, "flv"))
3596             max_stream_analyze_duration = 90*AV_TIME_BASE;
3597         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3598             max_stream_analyze_duration = 7*AV_TIME_BASE;
3599     }
3600
3601     if (ic->pb)
3602         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3603                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3604
3605     for (i = 0; i < ic->nb_streams; i++) {
3606         const AVCodec *codec;
3607         AVDictionary *thread_opt = NULL;
3608         st = ic->streams[i];
3609         avctx = st->internal->avctx;
3610
3611         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3612             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3613 /*            if (!st->time_base.num)
3614                 st->time_base = */
3615             if (!avctx->time_base.num)
3616                 avctx->time_base = st->time_base;
3617         }
3618
3619         /* check if the caller has overridden the codec id */
3620 #if FF_API_LAVF_AVCTX
3621 FF_DISABLE_DEPRECATION_WARNINGS
3622         if (st->codec->codec_id != st->internal->orig_codec_id) {
3623             st->codecpar->codec_id   = st->codec->codec_id;
3624             st->codecpar->codec_type = st->codec->codec_type;
3625             st->internal->orig_codec_id = st->codec->codec_id;
3626         }
3627 FF_ENABLE_DEPRECATION_WARNINGS
3628 #endif
3629         // only for the split stuff
3630         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3631             st->parser = av_parser_init(st->codecpar->codec_id);
3632             if (st->parser) {
3633                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3634                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3635                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3636                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3637                 }
3638             } else if (st->need_parsing) {
3639                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3640                        "%s, packets or times may be invalid.\n",
3641                        avcodec_get_name(st->codecpar->codec_id));
3642             }
3643         }
3644
3645         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3646             st->internal->orig_codec_id = st->codecpar->codec_id;
3647
3648         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3649         if (ret < 0)
3650             goto find_stream_info_err;
3651         if (st->request_probe <= 0)
3652             st->internal->avctx_inited = 1;
3653
3654         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3655
3656         /* Force thread count to 1 since the H.264 decoder will not extract
3657          * SPS and PPS to extradata during multi-threaded decoding. */
3658         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3659
3660         if (ic->codec_whitelist)
3661             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3662
3663         /* Ensure that subtitle_header is properly set. */
3664         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3665             && codec && !avctx->codec) {
3666             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3667                 av_log(ic, AV_LOG_WARNING,
3668                        "Failed to open codec in %s\n",__FUNCTION__);
3669         }
3670
3671         // Try to just open decoders, in case this is enough to get parameters.
3672         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3673             if (codec && !avctx->codec)
3674                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3675                     av_log(ic, AV_LOG_WARNING,
3676                            "Failed to open codec in %s\n",__FUNCTION__);
3677         }
3678         if (!options)
3679             av_dict_free(&thread_opt);
3680     }
3681
3682     for (i = 0; i < ic->nb_streams; i++) {
3683 #if FF_API_R_FRAME_RATE
3684         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3685 #endif
3686         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3687         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3688     }
3689
3690     read_size = 0;
3691     for (;;) {
3692         int analyzed_all_streams;
3693         if (ff_check_interrupt(&ic->interrupt_callback)) {
3694             ret = AVERROR_EXIT;
3695             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3696             break;
3697         }
3698
3699         /* check if one codec still needs to be handled */
3700         for (i = 0; i < ic->nb_streams; i++) {
3701             int fps_analyze_framecount = 20;
3702             int count;
3703
3704             st = ic->streams[i];
3705             if (!has_codec_parameters(st, NULL))
3706                 break;
3707             /* If the timebase is coarse (like the usual millisecond precision
3708              * of mkv), we need to analyze more frames to reliably arrive at
3709              * the correct fps. */
3710             if (av_q2d(st->time_base) > 0.0005)
3711                 fps_analyze_framecount *= 2;
3712             if (!tb_unreliable(st->internal->avctx))
3713                 fps_analyze_framecount = 0;
3714             if (ic->fps_probe_size >= 0)
3715                 fps_analyze_framecount = ic->fps_probe_size;
3716             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3717                 fps_analyze_framecount = 0;
3718             /* variable fps and no guess at the real fps */
3719             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3720                        st->info->codec_info_duration_fields/2 :
3721                        st->info->duration_count;
3722             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3723                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3724                 if (count < fps_analyze_framecount)
3725                     break;
3726             }
3727             // Look at the first 3 frames if there is evidence of frame delay
3728             // but the decoder delay is not set.
3729             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3730                 break;
3731             if (!st->internal->avctx->extradata &&
3732                 (!st->internal->extract_extradata.inited ||
3733                  st->internal->extract_extradata.bsf) &&
3734                 extract_extradata_check(st))
3735                 break;
3736             if (st->first_dts == AV_NOPTS_VALUE &&
3737                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3738                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3739                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3740                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3741                 break;
3742         }
3743         analyzed_all_streams = 0;
3744         if (!missing_streams || !*missing_streams)
3745         if (i == ic->nb_streams) {
3746             analyzed_all_streams = 1;
3747             /* NOTE: If the format has no header, then we need to read some
3748              * packets to get most of the streams, so we cannot stop here. */
3749             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3750                 /* If we found the info for all the codecs, we can stop. */
3751                 ret = count;
3752                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3753                 flush_codecs = 0;
3754                 break;
3755             }
3756         }
3757         /* We did not get all the codec info, but we read too much data. */
3758         if (read_size >= probesize) {
3759             ret = count;
3760             av_log(ic, AV_LOG_DEBUG,
3761                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3762             for (i = 0; i < ic->nb_streams; i++)
3763                 if (!ic->streams[i]->r_frame_rate.num &&
3764                     ic->streams[i]->info->duration_count <= 1 &&
3765                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3766                     strcmp(ic->iformat->name, "image2"))
3767                     av_log(ic, AV_LOG_WARNING,
3768                            "Stream #%d: not enough frames to estimate rate; "
3769                            "consider increasing probesize\n", i);
3770             break;
3771         }
3772
3773         /* NOTE: A new stream can be added there if no header in file
3774          * (AVFMTCTX_NOHEADER). */
3775         ret = read_frame_internal(ic, &pkt1);
3776         if (ret == AVERROR(EAGAIN))
3777             continue;
3778
3779         if (ret < 0) {
3780             /* EOF or error*/
3781             eof_reached = 1;
3782             break;
3783         }
3784
3785         pkt = &pkt1;
3786
3787         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3788             ret = ff_packet_list_put(&ic->internal->packet_buffer,
3789                                      &ic->internal->packet_buffer_end,
3790                                      pkt, 0);
3791             if (ret < 0)
3792                 goto find_stream_info_err;
3793         }
3794
3795         st = ic->streams[pkt->stream_index];
3796         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3797             read_size += pkt->size;
3798
3799         avctx = st->internal->avctx;
3800         if (!st->internal->avctx_inited) {
3801             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3802             if (ret < 0)
3803                 goto find_stream_info_err;
3804             st->internal->avctx_inited = 1;
3805         }
3806
3807         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3808             /* check for non-increasing dts */
3809             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3810                 st->info->fps_last_dts >= pkt->dts) {
3811                 av_log(ic, AV_LOG_DEBUG,
3812                        "Non-increasing DTS in stream %d: packet %d with DTS "
3813                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3814                        st->index, st->info->fps_last_dts_idx,
3815                        st->info->fps_last_dts, st->codec_info_nb_frames,
3816                        pkt->dts);
3817                 st->info->fps_first_dts =
3818                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3819             }
3820             /* Check for a discontinuity in dts. If the difference in dts
3821              * is more than 1000 times the average packet duration in the
3822              * sequence, we treat it as a discontinuity. */
3823             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3824                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3825                 (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3826                 (st->info->fps_last_dts     - (uint64_t)st->info->fps_first_dts) /
3827                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3828                 av_log(ic, AV_LOG_WARNING,
3829                        "DTS discontinuity in stream %d: packet %d with DTS "
3830                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3831                        st->index, st->info->fps_last_dts_idx,
3832                        st->info->fps_last_dts, st->codec_info_nb_frames,
3833                        pkt->dts);
3834                 st->info->fps_first_dts =
3835                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3836             }
3837
3838             /* update stored dts values */
3839             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3840                 st->info->fps_first_dts     = pkt->dts;
3841                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3842             }
3843             st->info->fps_last_dts     = pkt->dts;
3844             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3845         }
3846         if (st->codec_info_nb_frames>1) {
3847             int64_t t = 0;
3848             int64_t limit;
3849
3850             if (st->time_base.den > 0)
3851                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3852             if (st->avg_frame_rate.num > 0)
3853                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3854
3855             if (   t == 0
3856                 && st->codec_info_nb_frames>30
3857                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3858                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3859                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3860
3861             if (analyzed_all_streams)                                limit = max_analyze_duration;
3862             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3863             else                                                     limit = max_stream_analyze_duration;
3864
3865             if (t >= limit) {
3866                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3867                        limit,
3868                        t, pkt->stream_index);
3869                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3870                     av_packet_unref(pkt);
3871                 break;
3872             }
3873             if (pkt->duration) {
3874                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3875                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3876                 } else
3877                     st->info->codec_info_duration += pkt->duration;
3878                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3879             }
3880         }
3881         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3882 #if FF_API_R_FRAME_RATE
3883             ff_rfps_add_frame(ic, st, pkt->dts);
3884 #endif
3885             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3886                 st->info->frame_delay_evidence = 1;
3887         }
3888         if (!st->internal->avctx->extradata) {
3889             ret = extract_extradata(st, pkt);
3890             if (ret < 0)
3891                 goto find_stream_info_err;
3892         }
3893
3894         /* If still no information, we try to open the codec and to
3895          * decompress the frame. We try to avoid that in most cases as
3896          * it takes longer and uses more memory. For MPEG-4, we need to
3897          * decompress for QuickTime.
3898          *
3899          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3900          * least one frame of codec data, this makes sure the codec initializes
3901          * the channel configuration and does not only trust the values from
3902          * the container. */
3903         try_decode_frame(ic, st, pkt,
3904                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3905
3906         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3907             av_packet_unref(pkt);
3908
3909         st->codec_info_nb_frames++;
3910         count++;
3911     }
3912
3913     if (eof_reached) {
3914         int stream_index;
3915         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3916             st = ic->streams[stream_index];
3917             avctx = st->internal->avctx;
3918             if (!has_codec_parameters(st, NULL)) {
3919                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3920                 if (codec && !avctx->codec) {
3921                     AVDictionary *opts = NULL;
3922                     if (ic->codec_whitelist)
3923                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3924                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3925                         av_log(ic, AV_LOG_WARNING,
3926                                "Failed to open codec in %s\n",__FUNCTION__);
3927                     av_dict_free(&opts);
3928                 }
3929             }
3930
3931             // EOF already reached while reading the stream above.
3932             // So continue with reoordering DTS with whatever delay we have.
3933             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3934                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3935             }
3936         }
3937     }
3938
3939     if (flush_codecs) {
3940         AVPacket empty_pkt = { 0 };
3941         int err = 0;
3942         av_init_packet(&empty_pkt);
3943
3944         for (i = 0; i < ic->nb_streams; i++) {
3945
3946             st = ic->streams[i];
3947
3948             /* flush the decoders */
3949             if (st->info->found_decoder == 1) {
3950                 do {
3951                     err = try_decode_frame(ic, st, &empty_pkt,
3952                                             (options && i < orig_nb_streams)
3953                                             ? &options[i] : NULL);
3954                 } while (err > 0 && !has_codec_parameters(st, NULL));
3955
3956                 if (err < 0) {
3957                     av_log(ic, AV_LOG_INFO,
3958                         "decoding for stream %d failed\n", st->index);
3959                 }
3960             }
3961         }
3962     }
3963
3964     ff_rfps_calculate(ic);
3965
3966     for (i = 0; i < ic->nb_streams; i++) {
3967         st = ic->streams[i];
3968         avctx = st->internal->avctx;
3969         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3970             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3971                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3972                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3973                     avctx->codec_tag= tag;
3974             }
3975
3976             /* estimate average framerate if not set by demuxer */
3977             if (st->info->codec_info_duration_fields &&
3978                 !st->avg_frame_rate.num &&
3979                 st->info->codec_info_duration) {
3980                 int best_fps      = 0;
3981                 double best_error = 0.01;
3982                 AVRational codec_frame_rate = avctx->framerate;
3983
3984                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3985                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3986                     st->info->codec_info_duration        < 0)
3987                     continue;
3988                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3989                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3990                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3991
3992                 /* Round guessed framerate to a "standard" framerate if it's
3993                  * within 1% of the original estimate. */
3994                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3995                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3996                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3997                                               av_q2d(std_fps) - 1);
3998
3999                     if (error < best_error) {
4000                         best_error = error;
4001                         best_fps   = std_fps.num;
4002                     }
4003
4004                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4005                         error       = fabs(av_q2d(codec_frame_rate) /
4006                                            av_q2d(std_fps) - 1);
4007                         if (error < best_error) {
4008                             best_error = error;
4009                             best_fps   = std_fps.num;
4010                         }
4011                     }
4012                 }
4013                 if (best_fps)
4014                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4015                               best_fps, 12 * 1001, INT_MAX);
4016             }
4017
4018             if (!st->r_frame_rate.num) {
4019                 if (    avctx->time_base.den * (int64_t) st->time_base.num
4020                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
4021                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4022                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4023                 } else {
4024                     st->r_frame_rate.num = st->time_base.den;
4025                     st->r_frame_rate.den = st->time_base.num;
4026                 }
4027             }
4028             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
4029                 AVRational hw_ratio = { avctx->height, avctx->width };
4030                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
4031                                                    hw_ratio);
4032             }
4033         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4034             if (!avctx->bits_per_coded_sample)
4035                 avctx->bits_per_coded_sample =
4036                     av_get_bits_per_sample(avctx->codec_id);
4037             // set stream disposition based on audio service type
4038             switch (avctx->audio_service_type) {
4039             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4040                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4041                 break;
4042             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4043                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4044                 break;
4045             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4046                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4047                 break;
4048             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4049                 st->disposition = AV_DISPOSITION_COMMENT;
4050                 break;
4051             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4052                 st->disposition = AV_DISPOSITION_KARAOKE;
4053                 break;
4054             }
4055         }
4056     }
4057
4058     if (probesize)
4059         estimate_timings(ic, old_offset);
4060
4061     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4062
4063     if (ret >= 0 && ic->nb_streams)
4064         /* We could not have all the codec parameters before EOF. */
4065         ret = -1;
4066     for (i = 0; i < ic->nb_streams; i++) {
4067         const char *errmsg;
4068         st = ic->streams[i];
4069
4070         /* if no packet was ever seen, update context now for has_codec_parameters */
4071         if (!st->internal->avctx_inited) {
4072             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4073                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4074                 st->codecpar->format = st->internal->avctx->sample_fmt;
4075             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4076             if (ret < 0)
4077                 goto find_stream_info_err;
4078         }
4079         if (!has_codec_parameters(st, &errmsg)) {
4080             char buf[256];
4081             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4082             av_log(ic, AV_LOG_WARNING,
4083                    "Could not find codec parameters for stream %d (%s): %s\n"
4084                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4085                    i, buf, errmsg);
4086         } else {
4087             ret = 0;
4088         }
4089     }
4090
4091     compute_chapters_end(ic);
4092
4093     /* update the stream parameters from the internal codec contexts */
4094     for (i = 0; i < ic->nb_streams; i++) {
4095         st = ic->streams[i];
4096
4097         if (st->internal->avctx_inited) {
4098             int orig_w = st->codecpar->width;
4099             int orig_h = st->codecpar->height;
4100             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4101             if (ret < 0)
4102                 goto find_stream_info_err;
4103 #if FF_API_LOWRES
4104             // The decoder might reduce the video size by the lowres factor.
4105             if (st->internal->avctx->lowres && orig_w) {
4106                 st->codecpar->width = orig_w;
4107                 st->codecpar->height = orig_h;
4108             }
4109 #endif
4110         }
4111
4112 #if FF_API_LAVF_AVCTX
4113 FF_DISABLE_DEPRECATION_WARNINGS
4114         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4115         if (ret < 0)
4116             goto find_stream_info_err;
4117
4118 #if FF_API_LOWRES
4119         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4120         // by the lowres factor.
4121         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4122             st->codec->lowres = st->internal->avctx->lowres;
4123             st->codec->width = st->internal->avctx->width;
4124             st->codec->height = st->internal->avctx->height;
4125         }
4126 #endif
4127
4128         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4129             st->codec->time_base = st->internal->avctx->time_base;
4130             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4131         }
4132         st->codec->framerate = st->avg_frame_rate;
4133
4134         if (st->internal->avctx->subtitle_header) {
4135             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4136             if (!st->codec->subtitle_header)
4137                 goto find_stream_info_err;
4138             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4139             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4140                    st->codec->subtitle_header_size);
4141         }
4142
4143         // Fields unavailable in AVCodecParameters
4144         st->codec->coded_width = st->internal->avctx->coded_width;
4145         st->codec->coded_height = st->internal->avctx->coded_height;
4146         st->codec->properties = st->internal->avctx->properties;
4147 FF_ENABLE_DEPRECATION_WARNINGS
4148 #endif
4149
4150         st->internal->avctx_inited = 0;
4151     }
4152
4153 find_stream_info_err:
4154     for (i = 0; i < ic->nb_streams; i++) {
4155         st = ic->streams[i];
4156         if (st->info)
4157             av_freep(&st->info->duration_error);
4158         avcodec_close(ic->streams[i]->internal->avctx);
4159         av_freep(&ic->streams[i]->info);
4160         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4161         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4162     }
4163     if (ic->pb)
4164         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4165                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4166     return ret;
4167 }
4168
4169 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4170 {
4171     int i, j;
4172
4173     for (i = 0; i < ic->nb_programs; i++) {
4174         if (ic->programs[i] == last) {
4175             last = NULL;
4176         } else {
4177             if (!last)
4178                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4179                     if (ic->programs[i]->stream_index[j] == s)
4180                         return ic->programs[i];
4181         }
4182     }
4183     return NULL;
4184 }
4185
4186 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4187                         int wanted_stream_nb, int related_stream,
4188                         AVCodec **decoder_ret, int flags)
4189 {
4190     int i, nb_streams = ic->nb_streams;
4191     int ret = AVERROR_STREAM_NOT_FOUND;
4192     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4193     int count, multiframe, disposition;
4194     int64_t best_bitrate = -1;
4195     int64_t bitrate;
4196     unsigned *program = NULL;
4197     const AVCodec *decoder = NULL, *best_decoder = NULL;
4198
4199     if (related_stream >= 0 && wanted_stream_nb < 0) {
4200         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4201         if (p) {
4202             program    = p->stream_index;
4203             nb_streams = p->nb_stream_indexes;
4204         }
4205     }
4206     for (i = 0; i < nb_streams; i++) {
4207         int real_stream_index = program ? program[i] : i;
4208         AVStream *st          = ic->streams[real_stream_index];
4209         AVCodecParameters *par = st->codecpar;
4210         if (par->codec_type != type)
4211             continue;
4212         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4213             continue;
4214         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4215             continue;
4216         if (decoder_ret) {
4217             decoder = find_decoder(ic, st, par->codec_id);
4218             if (!decoder) {
4219                 if (ret < 0)
4220                     ret = AVERROR_DECODER_NOT_FOUND;
4221                 continue;
4222             }
4223         }
4224         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4225                       + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4226         count = st->codec_info_nb_frames;
4227         bitrate = par->bit_rate;
4228         multiframe = FFMIN(5, count);
4229         if ((best_disposition >  disposition) ||
4230             (best_disposition == disposition && best_multiframe >  multiframe) ||
4231             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4232             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4233             continue;
4234         best_disposition = disposition;
4235         best_count   = count;
4236         best_bitrate = bitrate;
4237         best_multiframe = multiframe;
4238         ret          = real_stream_index;
4239         best_decoder = decoder;
4240         if (program && i == nb_streams - 1 && ret < 0) {
4241             program    = NULL;
4242             nb_streams = ic->nb_streams;
4243             /* no related stream found, try again with everything */
4244             i = 0;
4245         }
4246     }
4247     if (decoder_ret)
4248         *decoder_ret = (AVCodec*)best_decoder;
4249     return ret;
4250 }
4251
4252 /*******************************************************/
4253
4254 int av_read_play(AVFormatContext *s)
4255 {
4256     if (s->iformat->read_play)
4257         return s->iformat->read_play(s);
4258     if (s->pb)
4259         return avio_pause(s->pb, 0);
4260     return AVERROR(ENOSYS);
4261 }
4262
4263 int av_read_pause(AVFormatContext *s)
4264 {
4265     if (s->iformat->read_pause)
4266         return s->iformat->read_pause(s);
4267     if (s->pb)
4268         return avio_pause(s->pb, 1);
4269     return AVERROR(ENOSYS);
4270 }
4271
4272 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4273 {
4274     int ret, i;
4275
4276     dst->id                  = src->id;
4277     dst->time_base           = src->time_base;
4278     dst->nb_frames           = src->nb_frames;
4279     dst->disposition         = src->disposition;
4280     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4281     dst->avg_frame_rate      = src->avg_frame_rate;
4282     dst->r_frame_rate        = src->r_frame_rate;
4283
4284     av_dict_free(&dst->metadata);
4285     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4286     if (ret < 0)
4287         return ret;
4288
4289     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4290     if (ret < 0)
4291         return ret;
4292
4293     /* Free existing side data*/
4294     for (i = 0; i < dst->nb_side_data; i++)
4295         av_free(dst->side_data[i].data);
4296     av_freep(&dst->side_data);
4297     dst->nb_side_data = 0;
4298
4299     /* Copy side data if present */
4300     if (src->nb_side_data) {
4301         dst->side_data = av_mallocz_array(src->nb_side_data,
4302                                           sizeof(AVPacketSideData));
4303         if (!dst->side_data)
4304             return AVERROR(ENOMEM);
4305         dst->nb_side_data = src->nb_side_data;
4306
4307         for (i = 0; i < src->nb_side_data; i++) {
4308             uint8_t *data = av_memdup(src->side_data[i].data,
4309                                       src->side_data[i].size);
4310             if (!data)
4311                 return AVERROR(ENOMEM);
4312             dst->side_data[i].type = src->side_data[i].type;
4313             dst->side_data[i].size = src->side_data[i].size;
4314             dst->side_data[i].data = data;
4315         }
4316     }
4317
4318 #if FF_API_LAVF_FFSERVER
4319 FF_DISABLE_DEPRECATION_WARNINGS
4320     av_freep(&dst->recommended_encoder_configuration);
4321     if (src->recommended_encoder_configuration) {
4322         const char *conf_str = src->recommended_encoder_configuration;
4323         dst->recommended_encoder_configuration = av_strdup(conf_str);
4324         if (!dst->recommended_encoder_configuration)
4325             return AVERROR(ENOMEM);
4326     }
4327 FF_ENABLE_DEPRECATION_WARNINGS
4328 #endif
4329
4330     return 0;
4331 }
4332
4333 static void free_stream(AVStream **pst)
4334 {
4335     AVStream *st = *pst;
4336     int i;
4337
4338     if (!st)
4339         return;
4340
4341     for (i = 0; i < st->nb_side_data; i++)
4342         av_freep(&st->side_data[i].data);
4343     av_freep(&st->side_data);
4344
4345     if (st->parser)
4346         av_parser_close(st->parser);
4347
4348     if (st->attached_pic.data)
4349         av_packet_unref(&st->attached_pic);
4350
4351     if (st->internal) {
4352         avcodec_free_context(&st->internal->avctx);
4353         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4354             av_bsf_free(&st->internal->bsfcs[i]);
4355             av_freep(&st->internal->bsfcs);
4356         }
4357         av_freep(&st->internal->priv_pts);
4358         av_bsf_free(&st->internal->extract_extradata.bsf);
4359         av_packet_free(&st->internal->extract_extradata.pkt);
4360     }
4361     av_freep(&st->internal);
4362
4363     av_dict_free(&st->metadata);
4364     avcodec_parameters_free(&st->codecpar);
4365     av_freep(&st->probe_data.buf);
4366     av_freep(&st->index_entries);
4367 #if FF_API_LAVF_AVCTX
4368 FF_DISABLE_DEPRECATION_WARNINGS
4369     avcodec_free_context(&st->codec);
4370 FF_ENABLE_DEPRECATION_WARNINGS
4371 #endif
4372     av_freep(&st->priv_data);
4373     if (st->info)
4374         av_freep(&st->info->duration_error);
4375     av_freep(&st->info);
4376 #if FF_API_LAVF_FFSERVER
4377 FF_DISABLE_DEPRECATION_WARNINGS
4378     av_freep(&st->recommended_encoder_configuration);
4379 FF_ENABLE_DEPRECATION_WARNINGS
4380 #endif
4381
4382     av_freep(pst);
4383 }
4384
4385 void ff_free_stream(AVFormatContext *s, AVStream *st)
4386 {
4387     av_assert0(s->nb_streams>0);
4388     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4389
4390     free_stream(&s->streams[ --s->nb_streams ]);
4391 }
4392
4393 void avformat_free_context(AVFormatContext *s)
4394 {
4395     int i;
4396
4397     if (!s)
4398         return;
4399
4400     av_opt_free(s);
4401     if (s->iformat && s->iformat->priv_class && s->priv_data)
4402         av_opt_free(s->priv_data);
4403     if (s->oformat && s->oformat->priv_class && s->priv_data)
4404         av_opt_free(s->priv_data);
4405
4406     for (i = s->nb_streams - 1; i >= 0; i--)
4407         ff_free_stream(s, s->streams[i]);
4408
4409
4410     for (i = s->nb_programs - 1; i >= 0; i--) {
4411         av_dict_free(&s->programs[i]->metadata);
4412         av_freep(&s->programs[i]->stream_index);
4413         av_freep(&s->programs[i]);
4414     }
4415     av_freep(&s->programs);
4416     av_freep(&s->priv_data);
4417     while (s->nb_chapters--) {
4418         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4419         av_freep(&s->chapters[s->nb_chapters]);
4420     }
4421     av_freep(&s->chapters);
4422     av_dict_free(&s->metadata);
4423     av_dict_free(&s->internal->id3v2_meta);
4424     av_freep(&s->streams);
4425     flush_packet_queue(s);
4426     av_freep(&s->internal);
4427     av_freep(&s->url);
4428     av_free(s);
4429 }
4430
4431 void avformat_close_input(AVFormatContext **ps)
4432 {
4433     AVFormatContext *s;
4434     AVIOContext *pb;
4435
4436     if (!ps || !*ps)
4437         return;
4438
4439     s  = *ps;
4440     pb = s->pb;
4441
4442     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4443         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4444         pb = NULL;
4445
4446     flush_packet_queue(s);
4447
4448     if (s->iformat)
4449         if (s->iformat->read_close)
4450             s->iformat->read_close(s);
4451
4452     avformat_free_context(s);
4453
4454     *ps = NULL;
4455
4456     avio_close(pb);
4457 }
4458
4459 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4460 {
4461     AVStream *st;
4462     int i;
4463     AVStream **streams;
4464
4465     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4466         if (s->max_streams < INT_MAX/sizeof(*streams))
4467             av_log(s, AV_LOG_ERROR, "Number of streams exceeds max_streams parameter (%d), see the documentation if you wish to increase it\n", s->max_streams);
4468         return NULL;
4469     }
4470     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4471     if (!streams)
4472         return NULL;
4473     s->streams = streams;
4474
4475     st = av_mallocz(sizeof(AVStream));
4476     if (!st)
4477         return NULL;
4478     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4479         av_free(st);
4480         return NULL;
4481     }
4482     st->info->last_dts = AV_NOPTS_VALUE;
4483
4484 #if FF_API_LAVF_AVCTX
4485 FF_DISABLE_DEPRECATION_WARNINGS
4486     st->codec = avcodec_alloc_context3(c);
4487     if (!st->codec) {
4488         av_free(st->info);
4489         av_free(st);
4490         return NULL;
4491     }
4492 FF_ENABLE_DEPRECATION_WARNINGS
4493 #endif
4494
4495     st->internal = av_mallocz(sizeof(*st->internal));
4496     if (!st->internal)
4497         goto fail;
4498
4499     st->codecpar = avcodec_parameters_alloc();
4500     if (!st->codecpar)
4501         goto fail;
4502
4503     st->internal->avctx = avcodec_alloc_context3(NULL);
4504     if (!st->internal->avctx)
4505         goto fail;
4506
4507     if (s->iformat) {
4508 #if FF_API_LAVF_AVCTX
4509 FF_DISABLE_DEPRECATION_WARNINGS
4510         /* no default bitrate if decoding */
4511         st->codec->bit_rate = 0;
4512 FF_ENABLE_DEPRECATION_WARNINGS
4513 #endif
4514
4515         /* default pts setting is MPEG-like */
4516         avpriv_set_pts_info(st, 33, 1, 90000);
4517         /* we set the current DTS to 0 so that formats without any timestamps
4518          * but durations get some timestamps, formats with some unknown
4519          * timestamps have their first few packets buffered and the
4520          * timestamps corrected before they are returned to the user */
4521         st->cur_dts = RELATIVE_TS_BASE;
4522     } else {
4523         st->cur_dts = AV_NOPTS_VALUE;
4524     }
4525
4526     st->index      = s->nb_streams;
4527     st->start_time = AV_NOPTS_VALUE;
4528     st->duration   = AV_NOPTS_VALUE;
4529     st->first_dts     = AV_NOPTS_VALUE;
4530     st->probe_packets = MAX_PROBE_PACKETS;
4531     st->pts_wrap_reference = AV_NOPTS_VALUE;
4532     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4533
4534     st->last_IP_pts = AV_NOPTS_VALUE;
4535     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4536     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4537         st->pts_buffer[i] = AV_NOPTS_VALUE;
4538
4539     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4540
4541 #if FF_API_R_FRAME_RATE
4542     st->info->last_dts      = AV_NOPTS_VALUE;
4543 #endif
4544     st->info->fps_first_dts = AV_NOPTS_VALUE;
4545     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4546
4547     st->inject_global_side_data = s->internal->inject_global_side_data;
4548
4549     st->internal->need_context_update = 1;
4550
4551     s->streams[s->nb_streams++] = st;
4552     return st;
4553 fail:
4554     free_stream(&st);
4555     return NULL;
4556 }
4557
4558 AVProgram *av_new_program(AVFormatContext *ac, int id)
4559 {
4560     AVProgram *program = NULL;
4561     int i;
4562
4563     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4564
4565     for (i = 0; i < ac->nb_programs; i++)
4566         if (ac->programs[i]->id == id)
4567             program = ac->programs[i];
4568
4569     if (!program) {
4570         program = av_mallocz(sizeof(AVProgram));
4571         if (!program)
4572             return NULL;
4573         dynarray_add(&ac->programs, &ac->nb_programs, program);
4574         program->discard = AVDISCARD_NONE;
4575         program->pmt_version = -1;
4576     }
4577     program->id = id;
4578     program->pts_wrap_reference = AV_NOPTS_VALUE;
4579     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4580
4581     program->start_time =
4582     program->end_time   = AV_NOPTS_VALUE;
4583
4584     return program;
4585 }
4586
4587 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4588                               int64_t start, int64_t end, const char *title)
4589 {
4590     AVChapter *chapter = NULL;
4591     int i;
4592
4593     if (end != AV_NOPTS_VALUE && start > end) {
4594         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4595         return NULL;
4596     }
4597
4598     for (i = 0; i < s->nb_chapters; i++)
4599         if (s->chapters[i]->id == id)
4600             chapter = s->chapters[i];
4601
4602     if (!chapter) {
4603         chapter = av_mallocz(sizeof(AVChapter));
4604         if (!chapter)
4605             return NULL;
4606         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4607     }
4608     av_dict_set(&chapter->metadata, "title", title, 0);
4609     chapter->id        = id;
4610     chapter->time_base = time_base;
4611     chapter->start     = start;
4612     chapter->end       = end;
4613
4614     return chapter;
4615 }
4616
4617 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4618 {
4619     int i, j;
4620     AVProgram *program = NULL;
4621     void *tmp;
4622
4623     if (idx >= ac->nb_streams) {
4624         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4625         return;
4626     }
4627
4628     for (i = 0; i < ac->nb_programs; i++) {
4629         if (ac->programs[i]->id != progid)
4630             continue;
4631         program = ac->programs[i];
4632         for (j = 0; j < program->nb_stream_indexes; j++)
4633             if (program->stream_index[j] == idx)
4634                 return;
4635
4636         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4637         if (!tmp)
4638             return;
4639         program->stream_index = tmp;
4640         program->stream_index[program->nb_stream_indexes++] = idx;
4641         return;
4642     }
4643 }
4644
4645 uint64_t ff_ntp_time(void)
4646 {
4647     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4648 }
4649
4650 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4651 {
4652     uint64_t ntp_ts, frac_part, sec;
4653     uint32_t usec;
4654
4655     //current ntp time in seconds and micro seconds
4656     sec = ntp_time_us / 1000000;
4657     usec = ntp_time_us % 1000000;
4658
4659     //encoding in ntp timestamp format
4660     frac_part = usec * 0xFFFFFFFFULL;
4661     frac_part /= 1000000;
4662
4663     if (sec > 0xFFFFFFFFULL)
4664         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4665
4666     ntp_ts = sec << 32;
4667     ntp_ts |= frac_part;
4668
4669     return ntp_ts;
4670 }
4671
4672 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4673 {
4674     const char *p;
4675     char *q, buf1[20], c;
4676     int nd, len, percentd_found;
4677
4678     q = buf;
4679     p = path;
4680     percentd_found = 0;
4681     for (;;) {
4682         c = *p++;
4683         if (c == '\0')
4684             break;
4685         if (c == '%') {
4686             do {
4687                 nd = 0;
4688                 while (av_isdigit(*p))
4689                     nd = nd * 10 + *p++ - '0';
4690                 c = *p++;
4691             } while (av_isdigit(c));
4692
4693             switch (c) {
4694             case '%':
4695                 goto addchar;
4696             case 'd':
4697                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4698                     goto fail;
4699                 percentd_found = 1;
4700                 if (number < 0)
4701                     nd += 1;
4702                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4703                 len = strlen(buf1);
4704                 if ((q - buf + len) > buf_size - 1)
4705                     goto fail;
4706                 memcpy(q, buf1, len);
4707                 q += len;
4708                 break;
4709             default:
4710                 goto fail;
4711             }
4712         } else {
4713 addchar:
4714             if ((q - buf) < buf_size - 1)
4715                 *q++ = c;
4716         }
4717     }
4718     if (!percentd_found)
4719         goto fail;
4720     *q = '\0';
4721     return 0;
4722 fail:
4723     *q = '\0';
4724     return -1;
4725 }
4726
4727 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4728 {
4729     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4730 }
4731
4732 void av_url_split(char *proto, int proto_size,
4733                   char *authorization, int authorization_size,
4734                   char *hostname, int hostname_size,
4735                   int *port_ptr, char *path, int path_size, const char *url)
4736 {
4737     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4738
4739     if (port_ptr)
4740         *port_ptr = -1;
4741     if (proto_size > 0)
4742         proto[0] = 0;
4743     if (authorization_size > 0)
4744         authorization[0] = 0;
4745     if (hostname_size > 0)
4746         hostname[0] = 0;
4747     if (path_size > 0)
4748         path[0] = 0;
4749
4750     /* parse protocol */
4751     if ((p = strchr(url, ':'))) {
4752         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4753         p++; /* skip ':' */
4754         if (*p == '/')
4755             p++;
4756         if (*p == '/')
4757             p++;
4758     } else {
4759         /* no protocol means plain filename */
4760         av_strlcpy(path, url, path_size);
4761         return;
4762     }
4763
4764     /* separate path from hostname */
4765     ls = strchr(p, '/');
4766     ls2 = strchr(p, '?');
4767     if (!ls)
4768         ls = ls2;
4769     else if (ls && ls2)
4770         ls = FFMIN(ls, ls2);
4771     if (ls)
4772         av_strlcpy(path, ls, path_size);
4773     else
4774         ls = &p[strlen(p)];  // XXX
4775
4776     /* the rest is hostname, use that to parse auth/port */
4777     if (ls != p) {
4778         /* authorization (user[:pass]@hostname) */
4779         at2 = p;
4780         while ((at = strchr(p, '@')) && at < ls) {
4781             av_strlcpy(authorization, at2,
4782                        FFMIN(authorization_size, at + 1 - at2));
4783             p = at + 1; /* skip '@' */
4784         }
4785
4786         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4787             /* [host]:port */
4788             av_strlcpy(hostname, p + 1,
4789                        FFMIN(hostname_size, brk - p));
4790             if (brk[1] == ':' && port_ptr)
4791                 *port_ptr = atoi(brk + 2);
4792         } else if ((col = strchr(p, ':')) && col < ls) {
4793             av_strlcpy(hostname, p,
4794                        FFMIN(col + 1 - p, hostname_size));
4795             if (port_ptr)
4796                 *port_ptr = atoi(col + 1);
4797         } else
4798             av_strlcpy(hostname, p,
4799                        FFMIN(ls + 1 - p, hostname_size));
4800     }
4801 }
4802
4803 int ff_mkdir_p(const char *path)
4804 {
4805     int ret = 0;
4806     char *temp = av_strdup(path);
4807     char *pos = temp;
4808     char tmp_ch = '\0';
4809
4810     if (!path || !temp) {
4811         return -1;
4812     }
4813
4814     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4815         pos++;
4816     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4817         pos += 2;
4818     }
4819
4820     for ( ; *pos != '\0'; ++pos) {
4821         if (*pos == '/' || *pos == '\\') {
4822             tmp_ch = *pos;
4823             *pos = '\0';
4824             ret = mkdir(temp, 0755);
4825             *pos = tmp_ch;
4826         }
4827     }
4828
4829     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4830         ret = mkdir(temp, 0755);
4831     }
4832
4833     av_free(temp);
4834     return ret;
4835 }
4836
4837 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4838 {
4839     int i;
4840     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4841                                            '4', '5', '6', '7',
4842                                            '8', '9', 'A', 'B',
4843                                            'C', 'D', 'E', 'F' };
4844     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4845                                            '4', '5', '6', '7',
4846                                            '8', '9', 'a', 'b',
4847                                            'c', 'd', 'e', 'f' };
4848     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4849
4850     for (i = 0; i < s; i++) {
4851         buff[i * 2]     = hex_table[src[i] >> 4];
4852         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4853     }
4854
4855     return buff;
4856 }
4857
4858 int ff_hex_to_data(uint8_t *data, const char *p)
4859 {
4860     int c, len, v;
4861
4862     len = 0;
4863     v   = 1;
4864     for (;;) {
4865         p += strspn(p, SPACE_CHARS);
4866         if (*p == '\0')
4867             break;
4868         c = av_toupper((unsigned char) *p++);
4869         if (c >= '0' && c <= '9')
4870             c = c - '0';
4871         else if (c >= 'A' && c <= 'F')
4872             c = c - 'A' + 10;
4873         else
4874             break;
4875         v = (v << 4) | c;
4876         if (v & 0x100) {
4877             if (data)
4878                 data[len] = v;
4879             len++;
4880             v = 1;
4881         }
4882     }
4883     return len;
4884 }
4885
4886 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4887                          unsigned int pts_num, unsigned int pts_den)
4888 {
4889     AVRational new_tb;
4890     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4891         if (new_tb.num != pts_num)
4892             av_log(NULL, AV_LOG_DEBUG,
4893                    "st:%d removing common factor %d from timebase\n",
4894                    s->index, pts_num / new_tb.num);
4895     } else
4896         av_log(NULL, AV_LOG_WARNING,
4897                "st:%d has too large timebase, reducing\n", s->index);
4898
4899     if (new_tb.num <= 0 || new_tb.den <= 0) {
4900         av_log(NULL, AV_LOG_ERROR,
4901                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4902                new_tb.num, new_tb.den,
4903                s->index);
4904         return;
4905     }
4906     s->time_base     = new_tb;
4907 #if FF_API_LAVF_AVCTX
4908 FF_DISABLE_DEPRECATION_WARNINGS
4909     s->codec->pkt_timebase = new_tb;
4910 FF_ENABLE_DEPRECATION_WARNINGS
4911 #endif
4912     s->internal->avctx->pkt_timebase = new_tb;
4913     s->pts_wrap_bits = pts_wrap_bits;
4914 }
4915
4916 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4917                         void *context)
4918 {
4919     const char *ptr = str;
4920
4921     /* Parse key=value pairs. */
4922     for (;;) {
4923         const char *key;
4924         char *dest = NULL, *dest_end;
4925         int key_len, dest_len = 0;
4926
4927         /* Skip whitespace and potential commas. */
4928         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4929             ptr++;
4930         if (!*ptr)
4931             break;
4932
4933         key = ptr;
4934
4935         if (!(ptr = strchr(key, '=')))
4936             break;
4937         ptr++;
4938         key_len = ptr - key;
4939
4940         callback_get_buf(context, key, key_len, &dest, &dest_len);
4941         dest_end = dest + dest_len - 1;
4942
4943         if (*ptr == '\"') {
4944             ptr++;
4945             while (*ptr && *ptr != '\"') {
4946                 if (*ptr == '\\') {
4947                     if (!ptr[1])
4948                         break;
4949                     if (dest && dest < dest_end)
4950                         *dest++ = ptr[1];
4951                     ptr += 2;
4952                 } else {
4953                     if (dest && dest < dest_end)
4954                         *dest++ = *ptr;
4955                     ptr++;
4956                 }
4957             }
4958             if (*ptr == '\"')
4959                 ptr++;
4960         } else {
4961             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4962                 if (dest && dest < dest_end)
4963                     *dest++ = *ptr;
4964         }
4965         if (dest)
4966             *dest = 0;
4967     }
4968 }
4969
4970 int ff_find_stream_index(AVFormatContext *s, int id)
4971 {
4972     int i;
4973     for (i = 0; i < s->nb_streams; i++)
4974         if (s->streams[i]->id == id)
4975             return i;
4976     return -1;
4977 }
4978
4979 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4980                          int std_compliance)
4981 {
4982     if (ofmt) {
4983         unsigned int codec_tag;
4984         if (ofmt->query_codec)
4985             return ofmt->query_codec(codec_id, std_compliance);
4986         else if (ofmt->codec_tag)
4987             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4988         else if (codec_id == ofmt->video_codec ||
4989                  codec_id == ofmt->audio_codec ||
4990                  codec_id == ofmt->subtitle_codec ||
4991                  codec_id == ofmt->data_codec)
4992             return 1;
4993     }
4994     return AVERROR_PATCHWELCOME;
4995 }
4996
4997 int avformat_network_init(void)
4998 {
4999 #if CONFIG_NETWORK
5000     int ret;
5001     if ((ret = ff_network_init()) < 0)
5002         return ret;
5003     if ((ret = ff_tls_init()) < 0)
5004         return ret;
5005 #endif
5006     return 0;
5007 }
5008
5009 int avformat_network_deinit(void)
5010 {
5011 #if CONFIG_NETWORK
5012     ff_network_close();
5013     ff_tls_deinit();
5014 #endif
5015     return 0;
5016 }
5017
5018 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5019                         uint64_t channel_layout, int32_t sample_rate,
5020                         int32_t width, int32_t height)
5021 {
5022     uint32_t flags = 0;
5023     int size = 4;
5024     uint8_t *data;
5025     if (!pkt)
5026         return AVERROR(EINVAL);
5027     if (channels) {
5028         size  += 4;
5029         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5030     }
5031     if (channel_layout) {
5032         size  += 8;
5033         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5034     }
5035     if (sample_rate) {
5036         size  += 4;
5037         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5038     }
5039     if (width || height) {
5040         size  += 8;
5041         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5042     }
5043     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5044     if (!data)
5045         return AVERROR(ENOMEM);
5046     bytestream_put_le32(&data, flags);
5047     if (channels)
5048         bytestream_put_le32(&data, channels);
5049     if (channel_layout)
5050         bytestream_put_le64(&data, channel_layout);
5051     if (sample_rate)
5052         bytestream_put_le32(&data, sample_rate);
5053     if (width || height) {
5054         bytestream_put_le32(&data, width);
5055         bytestream_put_le32(&data, height);
5056     }
5057     return 0;
5058 }
5059
5060 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5061 {
5062     AVRational undef = {0, 1};
5063     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5064     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5065     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5066
5067     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5068                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5069     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5070         stream_sample_aspect_ratio = undef;
5071
5072     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5073                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5074     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5075         frame_sample_aspect_ratio = undef;
5076
5077     if (stream_sample_aspect_ratio.num)
5078         return stream_sample_aspect_ratio;
5079     else
5080         return frame_sample_aspect_ratio;
5081 }
5082
5083 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5084 {
5085     AVRational fr = st->r_frame_rate;
5086     AVRational codec_fr = st->internal->avctx->framerate;
5087     AVRational   avg_fr = st->avg_frame_rate;
5088
5089     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5090         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5091         fr = avg_fr;
5092     }
5093
5094
5095     if (st->internal->avctx->ticks_per_frame > 1) {
5096         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5097             (fr.num == 0 || av_q2d(codec_fr) < av_q2d(fr)*0.7 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1))
5098             fr = codec_fr;
5099     }
5100
5101     return fr;
5102 }
5103
5104 /**
5105  * Matches a stream specifier (but ignores requested index).
5106  *
5107  * @param indexptr set to point to the requested stream index if there is one
5108  *
5109  * @return <0 on error
5110  *         0  if st is NOT a matching stream
5111  *         >0 if st is a matching stream
5112  */
5113 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5114                                   const char *spec, const char **indexptr, AVProgram **p)
5115 {
5116     int match = 1;                      /* Stores if the specifier matches so far. */
5117     while (*spec) {
5118         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5119             if (indexptr)
5120                 *indexptr = spec;
5121             return match;
5122         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5123                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5124             enum AVMediaType type;
5125             int nopic = 0;
5126
5127             switch (*spec++) {
5128             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5129             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5130             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5131             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5132             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5133             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5134             default:  av_assert0(0);
5135             }
5136             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5137                 return AVERROR(EINVAL);
5138
5139 #if FF_API_LAVF_AVCTX
5140 FF_DISABLE_DEPRECATION_WARNINGS
5141             if (type != st->codecpar->codec_type
5142                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5143                 match = 0;
5144     FF_ENABLE_DEPRECATION_WARNINGS
5145 #else
5146             if (type != st->codecpar->codec_type)
5147                 match = 0;
5148 #endif
5149             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5150                 match = 0;
5151         } else if (*spec == 'p' && *(spec + 1) == ':') {
5152             int prog_id, i, j;
5153             int found = 0;
5154             char *endptr;
5155             spec += 2;
5156             prog_id = strtol(spec, &endptr, 0);
5157             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5158             if (spec == endptr || (*endptr && *endptr++ != ':'))
5159                 return AVERROR(EINVAL);
5160             spec = endptr;
5161             if (match) {
5162                 for (i = 0; i < s->nb_programs; i++) {
5163                     if (s->programs[i]->id != prog_id)
5164                         continue;
5165
5166                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5167                         if (st->index == s->programs[i]->stream_index[j]) {
5168                             found = 1;
5169                             if (p)
5170                                 *p = s->programs[i];
5171                             i = s->nb_programs;
5172                             break;
5173                         }
5174                     }
5175                 }
5176             }
5177             if (!found)
5178                 match = 0;
5179         } else if (*spec == '#' ||
5180                    (*spec == 'i' && *(spec + 1) == ':')) {
5181             int stream_id;
5182             char *endptr;
5183             spec += 1 + (*spec == 'i');
5184             stream_id = strtol(spec, &endptr, 0);
5185             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5186                 return AVERROR(EINVAL);
5187             return match && (stream_id == st->id);
5188         } else if (*spec == 'm' && *(spec + 1) == ':') {
5189             AVDictionaryEntry *tag;
5190             char *key, *val;
5191             int ret;
5192
5193             if (match) {
5194                spec += 2;
5195                val = strchr(spec, ':');
5196
5197                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5198                if (!key)
5199                    return AVERROR(ENOMEM);
5200
5201                tag = av_dict_get(st->metadata, key, NULL, 0);
5202                if (tag) {
5203                    if (!val || !strcmp(tag->value, val + 1))
5204                        ret = 1;
5205                    else
5206                        ret = 0;
5207                } else
5208                    ret = 0;
5209
5210                av_freep(&key);
5211             }
5212             return match && ret;
5213         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5214             AVCodecParameters *par = st->codecpar;
5215 #if FF_API_LAVF_AVCTX
5216 FF_DISABLE_DEPRECATION_WARNINGS
5217             AVCodecContext *codec = st->codec;
5218 FF_ENABLE_DEPRECATION_WARNINGS
5219 #endif
5220             int val;
5221             switch (par->codec_type) {
5222             case AVMEDIA_TYPE_AUDIO:
5223                 val = par->sample_rate && par->channels;
5224 #if FF_API_LAVF_AVCTX
5225                 val = val || (codec->sample_rate && codec->channels);
5226 #endif
5227                 if (par->format == AV_SAMPLE_FMT_NONE
5228 #if FF_API_LAVF_AVCTX
5229                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5230 #endif
5231                     )
5232                     return 0;
5233                 break;
5234             case AVMEDIA_TYPE_VIDEO:
5235                 val = par->width && par->height;
5236 #if FF_API_LAVF_AVCTX
5237                 val = val || (codec->width && codec->height);
5238 #endif
5239                 if (par->format == AV_PIX_FMT_NONE
5240 #if FF_API_LAVF_AVCTX
5241                     && codec->pix_fmt == AV_PIX_FMT_NONE
5242 #endif
5243                     )
5244                     return 0;
5245                 break;
5246             case AVMEDIA_TYPE_UNKNOWN:
5247                 val = 0;
5248                 break;
5249             default:
5250                 val = 1;
5251                 break;
5252             }
5253 #if FF_API_LAVF_AVCTX
5254             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5255 #else
5256             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5257 #endif
5258         } else {
5259             return AVERROR(EINVAL);
5260         }
5261     }
5262
5263     return match;
5264 }
5265
5266
5267 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5268                                     const char *spec)
5269 {
5270     int ret, index;
5271     char *endptr;
5272     const char *indexptr = NULL;
5273     AVProgram *p = NULL;
5274     int nb_streams;
5275
5276     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5277     if (ret < 0)
5278         goto error;
5279
5280     if (!indexptr)
5281         return ret;
5282
5283     index = strtol(indexptr, &endptr, 0);
5284     if (*endptr) {                  /* We can't have anything after the requested index. */
5285         ret = AVERROR(EINVAL);
5286         goto error;
5287     }
5288
5289     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5290     if (spec == indexptr)
5291         return (index == st->index);
5292
5293     /* If we requested a matching stream index, we have to ensure st is that. */
5294     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5295     for (int i = 0; i < nb_streams && index >= 0; i++) {
5296         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5297         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5298         if (ret < 0)
5299             goto error;
5300         if (ret > 0 && index-- == 0 && st == candidate)
5301             return 1;
5302     }
5303     return 0;
5304
5305 error:
5306     if (ret == AVERROR(EINVAL))
5307         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5308     return ret;
5309 }
5310
5311 int ff_generate_avci_extradata(AVStream *st)
5312 {
5313     static const uint8_t avci100_1080p_extradata[] = {
5314         // SPS
5315         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5316         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5317         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5318         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5319         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5320         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5321         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5322         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5323         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5324         // PPS
5325         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5326         0xd0
5327     };
5328     static const uint8_t avci100_1080i_extradata[] = {
5329         // SPS
5330         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5331         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5332         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5333         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5334         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5335         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5336         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5337         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5338         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5339         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5340         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5341         // PPS
5342         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5343         0xd0
5344     };
5345     static const uint8_t avci50_1080p_extradata[] = {
5346         // SPS
5347         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5348         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5349         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5350         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5351         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5352         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5353         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5354         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5355         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5356         // PPS
5357         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5358         0x11
5359     };
5360     static const uint8_t avci50_1080i_extradata[] = {
5361         // SPS
5362         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5363         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5364         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5365         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5366         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5367         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5368         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5369         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5370         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5371         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5372         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5373         // PPS
5374         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5375         0x11
5376     };
5377     static const uint8_t avci100_720p_extradata[] = {
5378         // SPS
5379         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5380         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5381         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5382         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5383         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5384         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5385         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5386         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5387         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5388         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5389         // PPS
5390         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5391         0x11
5392     };
5393     static const uint8_t avci50_720p_extradata[] = {
5394         // SPS
5395         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5396         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5397         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5398         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5399         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5400         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5401         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5402         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5403         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5404         // PPS
5405         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5406         0x11
5407     };
5408
5409     const uint8_t *data = NULL;
5410     int size            = 0;
5411
5412     if (st->codecpar->width == 1920) {
5413         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5414             data = avci100_1080p_extradata;
5415             size = sizeof(avci100_1080p_extradata);
5416         } else {
5417             data = avci100_1080i_extradata;
5418             size = sizeof(avci100_1080i_extradata);
5419         }
5420     } else if (st->codecpar->width == 1440) {
5421         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5422             data = avci50_1080p_extradata;
5423             size = sizeof(avci50_1080p_extradata);
5424         } else {
5425             data = avci50_1080i_extradata;
5426             size = sizeof(avci50_1080i_extradata);
5427         }
5428     } else if (st->codecpar->width == 1280) {
5429         data = avci100_720p_extradata;
5430         size = sizeof(avci100_720p_extradata);
5431     } else if (st->codecpar->width == 960) {
5432         data = avci50_720p_extradata;
5433         size = sizeof(avci50_720p_extradata);
5434     }
5435
5436     if (!size)
5437         return 0;
5438
5439     av_freep(&st->codecpar->extradata);
5440     if (ff_alloc_extradata(st->codecpar, size))
5441         return AVERROR(ENOMEM);
5442     memcpy(st->codecpar->extradata, data, size);
5443
5444     return 0;
5445 }
5446
5447 uint8_t *av_stream_get_side_data(const AVStream *st,
5448                                  enum AVPacketSideDataType type, int *size)
5449 {
5450     int i;
5451
5452     for (i = 0; i < st->nb_side_data; i++) {
5453         if (st->side_data[i].type == type) {
5454             if (size)
5455                 *size = st->side_data[i].size;
5456             return st->side_data[i].data;
5457         }
5458     }
5459     return NULL;
5460 }
5461
5462 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5463                             uint8_t *data, size_t size)
5464 {
5465     AVPacketSideData *sd, *tmp;
5466     int i;
5467
5468     for (i = 0; i < st->nb_side_data; i++) {
5469         sd = &st->side_data[i];
5470
5471         if (sd->type == type) {
5472             av_freep(&sd->data);
5473             sd->data = data;
5474             sd->size = size;
5475             return 0;
5476         }
5477     }
5478
5479     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5480         return AVERROR(ERANGE);
5481
5482     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5483     if (!tmp) {
5484         return AVERROR(ENOMEM);
5485     }
5486
5487     st->side_data = tmp;
5488     st->nb_side_data++;
5489
5490     sd = &st->side_data[st->nb_side_data - 1];
5491     sd->type = type;
5492     sd->data = data;
5493     sd->size = size;
5494
5495     return 0;
5496 }
5497
5498 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5499                                  int size)
5500 {
5501     int ret;
5502     uint8_t *data = av_malloc(size);
5503
5504     if (!data)
5505         return NULL;
5506
5507     ret = av_stream_add_side_data(st, type, data, size);
5508     if (ret < 0) {
5509         av_freep(&data);
5510         return NULL;
5511     }
5512
5513     return data;
5514 }
5515
5516 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5517 {
5518     int ret;
5519     const AVBitStreamFilter *bsf;
5520     AVBSFContext *bsfc;
5521     AVCodecParameters *in_par;
5522
5523     if (!(bsf = av_bsf_get_by_name(name))) {
5524         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5525         return AVERROR_BSF_NOT_FOUND;
5526     }
5527
5528     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5529         return ret;
5530
5531     if (st->internal->nb_bsfcs) {
5532         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5533         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5534     } else {
5535         in_par = st->codecpar;
5536         bsfc->time_base_in = st->time_base;
5537     }
5538
5539     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5540         av_bsf_free(&bsfc);
5541         return ret;
5542     }
5543
5544     if (args && bsfc->filter->priv_class) {
5545         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5546         const char * shorthand[2] = {NULL};
5547
5548         if (opt)
5549             shorthand[0] = opt->name;
5550
5551         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5552             av_bsf_free(&bsfc);
5553             return ret;
5554         }
5555     }
5556
5557     if ((ret = av_bsf_init(bsfc)) < 0) {
5558         av_bsf_free(&bsfc);
5559         return ret;
5560     }
5561
5562     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5563         av_bsf_free(&bsfc);
5564         return ret;
5565     }
5566
5567     av_log(NULL, AV_LOG_VERBOSE,
5568            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5569            name, args ? args : "");
5570     return 1;
5571 }
5572
5573 #if FF_API_OLD_BSF
5574 FF_DISABLE_DEPRECATION_WARNINGS
5575 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5576                                AVBitStreamFilterContext *bsfc)
5577 {
5578     int ret = 0;
5579     while (bsfc) {
5580         AVPacket new_pkt = *pkt;
5581         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5582                                            &new_pkt.data, &new_pkt.size,
5583                                            pkt->data, pkt->size,
5584                                            pkt->flags & AV_PKT_FLAG_KEY);
5585         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5586             av_packet_unref(pkt);
5587             memset(pkt, 0, sizeof(*pkt));
5588             return 0;
5589         }
5590         if(a == 0 && new_pkt.data != pkt->data) {
5591             uint8_t *t = av_malloc(new_pkt.size + AV_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow
5592             if (t) {
5593                 memcpy(t, new_pkt.data, new_pkt.size);
5594                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5595                 new_pkt.data = t;
5596                 new_pkt.buf = NULL;
5597                 a = 1;
5598             } else {
5599                 a = AVERROR(ENOMEM);
5600             }
5601         }
5602         if (a > 0) {
5603             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5604                                            av_buffer_default_free, NULL, 0);
5605             if (new_pkt.buf) {
5606                 pkt->side_data = NULL;
5607                 pkt->side_data_elems = 0;
5608                 av_packet_unref(pkt);
5609             } else {
5610                 av_freep(&new_pkt.data);
5611                 a = AVERROR(ENOMEM);
5612             }
5613         }
5614         if (a < 0) {
5615             av_log(codec, AV_LOG_ERROR,
5616                    "Failed to open bitstream filter %s for stream %d with codec %s",
5617                    bsfc->filter->name, pkt->stream_index,
5618                    codec->codec ? codec->codec->name : "copy");
5619             ret = a;
5620             break;
5621         }
5622         *pkt = new_pkt;
5623
5624         bsfc = bsfc->next;
5625     }
5626     return ret;
5627 }
5628 FF_ENABLE_DEPRECATION_WARNINGS
5629 #endif
5630
5631 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5632 {
5633     if (!s->oformat)
5634         return AVERROR(EINVAL);
5635
5636     if (!(s->oformat->flags & AVFMT_NOFILE))
5637         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5638     return 0;
5639 }
5640
5641 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5642 {
5643     if (*pb)
5644         s->io_close(s, *pb);
5645     *pb = NULL;
5646 }
5647
5648 int ff_is_http_proto(char *filename) {
5649     const char *proto = avio_find_protocol_name(filename);
5650     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5651 }
5652
5653 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5654 {
5655     AVDictionaryEntry *entry;
5656     int64_t parsed_timestamp;
5657     int ret;
5658     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5659         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5660             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5661             return 1;
5662         } else {
5663             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5664             return ret;
5665         }
5666     }
5667     return 0;
5668 }
5669
5670 int ff_standardize_creation_time(AVFormatContext *s)
5671 {
5672     int64_t timestamp;
5673     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5674     if (ret == 1)
5675         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5676     return ret;
5677 }
5678
5679 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5680 {
5681     uint8_t *side_data;
5682     int size;
5683
5684     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5685     if (side_data) {
5686         if (size != AVPALETTE_SIZE) {
5687             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5688             return AVERROR_INVALIDDATA;
5689         }
5690         memcpy(palette, side_data, AVPALETTE_SIZE);
5691         return 1;
5692     }
5693
5694     if (ret == CONTAINS_PAL) {
5695         int i;
5696         for (i = 0; i < AVPALETTE_COUNT; i++)
5697             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5698         return 1;
5699     }
5700
5701     return 0;
5702 }
5703
5704 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5705 {
5706     int ret;
5707     char *str;
5708
5709     ret = av_bprint_finalize(buf, &str);
5710     if (ret < 0)
5711         return ret;
5712     if (!av_bprint_is_complete(buf)) {
5713         av_free(str);
5714         return AVERROR(ENOMEM);
5715     }
5716
5717     par->extradata = str;
5718     /* Note: the string is NUL terminated (so extradata can be read as a
5719      * string), but the ending character is not accounted in the size (in
5720      * binary formats you are likely not supposed to mux that character). When
5721      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5722      * zeros. */
5723     par->extradata_size = buf->len;
5724     return 0;
5725 }
5726
5727 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5728                                                   AVStream *ost, const AVStream *ist,
5729                                                   enum AVTimebaseSource copy_tb)
5730 {
5731     //TODO: use [io]st->internal->avctx
5732     const AVCodecContext *dec_ctx = ist->codec;
5733     AVCodecContext       *enc_ctx = ost->codec;
5734
5735     enc_ctx->time_base = ist->time_base;
5736     /*
5737      * Avi is a special case here because it supports variable fps but
5738      * having the fps and timebase differe significantly adds quite some
5739      * overhead
5740      */
5741     if (!strcmp(ofmt->name, "avi")) {
5742 #if FF_API_R_FRAME_RATE
5743         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5744             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5745             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5746             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5747             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5748             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5749             enc_ctx->time_base.num = ist->r_frame_rate.den;
5750             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5751             enc_ctx->ticks_per_frame = 2;
5752         } else
5753 #endif
5754             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5755                    && av_q2d(ist->time_base) < 1.0/500
5756                    || copy_tb == AVFMT_TBCF_DECODER) {
5757             enc_ctx->time_base = dec_ctx->time_base;
5758             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5759             enc_ctx->time_base.den *= 2;
5760             enc_ctx->ticks_per_frame = 2;
5761         }
5762     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5763                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5764         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5765             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5766             && av_q2d(ist->time_base) < 1.0/500
5767             || copy_tb == AVFMT_TBCF_DECODER) {
5768             enc_ctx->time_base = dec_ctx->time_base;
5769             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5770         }
5771     }
5772
5773     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5774         && dec_ctx->time_base.num < dec_ctx->time_base.den
5775         && dec_ctx->time_base.num > 0
5776         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5777         enc_ctx->time_base = dec_ctx->time_base;
5778     }
5779
5780     if (ost->avg_frame_rate.num)
5781         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5782
5783     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5784               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5785
5786     return 0;
5787 }
5788
5789 AVRational av_stream_get_codec_timebase(const AVStream *st)
5790 {
5791     // See avformat_transfer_internal_stream_timing_info() TODO.
5792 #if FF_API_LAVF_AVCTX
5793 FF_DISABLE_DEPRECATION_WARNINGS
5794     return st->codec->time_base;
5795 FF_ENABLE_DEPRECATION_WARNINGS
5796 #else
5797     return st->internal->avctx->time_base;
5798 #endif
5799 }
5800
5801 void ff_format_set_url(AVFormatContext *s, char *url)
5802 {
5803     av_assert0(url);
5804     av_freep(&s->url);
5805     s->url = url;
5806 #if FF_API_FORMAT_FILENAME
5807 FF_DISABLE_DEPRECATION_WARNINGS
5808     av_strlcpy(s->filename, url, sizeof(s->filename));
5809 FF_ENABLE_DEPRECATION_WARNINGS
5810 #endif
5811 }