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     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                         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")) {
 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_TRACE,
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)
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             st->last_IP_duration = pkt->duration;
1368             st->last_IP_pts      = pkt->pts;
1369             /* Cannot compute PTS if not present (we can compute it only
1370              * by knowing the future. */
1371         } else if (pkt->pts != AV_NOPTS_VALUE ||
1372                    pkt->dts != AV_NOPTS_VALUE ||
1373                    pkt->duration                ) {
1374
1375             /* presentation is not delayed : PTS and DTS are the same */
1376             if (pkt->pts == AV_NOPTS_VALUE)
1377                 pkt->pts = pkt->dts;
1378             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1379                                       pkt->pts, pkt);
1380             if (pkt->pts == AV_NOPTS_VALUE)
1381                 pkt->pts = st->cur_dts;
1382             pkt->dts = pkt->pts;
1383             if (pkt->pts != AV_NOPTS_VALUE)
1384                 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1385         }
1386     }
1387
1388     if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1389         st->pts_buffer[0] = pkt->pts;
1390         for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1391             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1392
1393         if(has_decode_delay_been_guessed(st))
1394             pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1395     }
1396     // We skipped it above so we try here.
1397     if (!onein_oneout)
1398         // This should happen on the first packet
1399         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1400     if (pkt->dts > st->cur_dts)
1401         st->cur_dts = pkt->dts;
1402
1403     if (s->debug & FF_FDEBUG_TS)
1404         av_log(s, AV_LOG_TRACE, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1405             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1406
1407     /* update flags */
1408     if (is_intra_only(st->codecpar->codec_id))
1409         pkt->flags |= AV_PKT_FLAG_KEY;
1410 #if FF_API_CONVERGENCE_DURATION
1411 FF_DISABLE_DEPRECATION_WARNINGS
1412     if (pc)
1413         pkt->convergence_duration = pc->convergence_duration;
1414 FF_ENABLE_DEPRECATION_WARNINGS
1415 #endif
1416 }
1417
1418 void ff_packet_list_free(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1419 {
1420     AVPacketList *tmp = *pkt_buf;
1421
1422     while (tmp) {
1423         AVPacketList *pktl = tmp;
1424         tmp = pktl->next;
1425         av_packet_unref(&pktl->pkt);
1426         av_freep(&pktl);
1427     }
1428     *pkt_buf     = NULL;
1429     *pkt_buf_end = NULL;
1430 }
1431
1432 /**
1433  * Parse a packet, add all split parts to parse_queue.
1434  *
1435  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1436  */
1437 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1438 {
1439     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1440     AVStream *st = s->streams[stream_index];
1441     uint8_t *data = pkt ? pkt->data : NULL;
1442     int size      = pkt ? pkt->size : 0;
1443     int ret = 0, got_output = 0;
1444
1445     if (!pkt) {
1446         av_init_packet(&flush_pkt);
1447         pkt        = &flush_pkt;
1448         got_output = 1;
1449     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1450         // preserve 0-size sync packets
1451         compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1452     }
1453
1454     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1455         int len;
1456         int64_t next_pts = pkt->pts;
1457         int64_t next_dts = pkt->dts;
1458
1459         av_init_packet(&out_pkt);
1460         len = av_parser_parse2(st->parser, st->internal->avctx,
1461                                &out_pkt.data, &out_pkt.size, data, size,
1462                                pkt->pts, pkt->dts, pkt->pos);
1463
1464         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1465         pkt->pos = -1;
1466         /* increment read pointer */
1467         data += len;
1468         size -= len;
1469
1470         got_output = !!out_pkt.size;
1471
1472         if (!out_pkt.size)
1473             continue;
1474
1475         if (pkt->buf && out_pkt.data == pkt->data) {
1476             /* reference pkt->buf only when out_pkt.data is guaranteed to point
1477              * to data in it and not in the parser's internal buffer. */
1478             /* XXX: Ensure this is the case with all parsers when st->parser->flags
1479              * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */
1480             out_pkt.buf = av_buffer_ref(pkt->buf);
1481             if (!out_pkt.buf) {
1482                 ret = AVERROR(ENOMEM);
1483                 goto fail;
1484             }
1485         } else {
1486             ret = av_packet_make_refcounted(&out_pkt);
1487             if (ret < 0)
1488                 goto fail;
1489         }
1490
1491         if (pkt->side_data) {
1492             out_pkt.side_data       = pkt->side_data;
1493             out_pkt.side_data_elems = pkt->side_data_elems;
1494             pkt->side_data          = NULL;
1495             pkt->side_data_elems    = 0;
1496         }
1497
1498         /* set the duration */
1499         out_pkt.duration = (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1500         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1501             if (st->internal->avctx->sample_rate > 0) {
1502                 out_pkt.duration =
1503                     av_rescale_q_rnd(st->parser->duration,
1504                                      (AVRational) { 1, st->internal->avctx->sample_rate },
1505                                      st->time_base,
1506                                      AV_ROUND_DOWN);
1507             }
1508         }
1509
1510         out_pkt.stream_index = st->index;
1511         out_pkt.pts          = st->parser->pts;
1512         out_pkt.dts          = st->parser->dts;
1513         out_pkt.pos          = st->parser->pos;
1514         out_pkt.flags       |= pkt->flags & AV_PKT_FLAG_DISCARD;
1515
1516         if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1517             out_pkt.pos = st->parser->frame_offset;
1518
1519         if (st->parser->key_frame == 1 ||
1520             (st->parser->key_frame == -1 &&
1521              st->parser->pict_type == AV_PICTURE_TYPE_I))
1522             out_pkt.flags |= AV_PKT_FLAG_KEY;
1523
1524         if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1525             out_pkt.flags |= AV_PKT_FLAG_KEY;
1526
1527         compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1528
1529         ret = ff_packet_list_put(&s->internal->parse_queue,
1530                                  &s->internal->parse_queue_end,
1531                                  &out_pkt, 0);
1532         if (ret < 0) {
1533             av_packet_unref(&out_pkt);
1534             goto fail;
1535         }
1536     }
1537
1538     /* end of the stream => close and free the parser */
1539     if (pkt == &flush_pkt) {
1540         av_parser_close(st->parser);
1541         st->parser = NULL;
1542     }
1543
1544 fail:
1545     av_packet_unref(pkt);
1546     return ret;
1547 }
1548
1549 int ff_packet_list_get(AVPacketList **pkt_buffer,
1550                        AVPacketList **pkt_buffer_end,
1551                        AVPacket      *pkt)
1552 {
1553     AVPacketList *pktl;
1554     av_assert0(*pkt_buffer);
1555     pktl        = *pkt_buffer;
1556     *pkt        = pktl->pkt;
1557     *pkt_buffer = pktl->next;
1558     if (!pktl->next)
1559         *pkt_buffer_end = NULL;
1560     av_freep(&pktl);
1561     return 0;
1562 }
1563
1564 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1565 {
1566     return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1567 }
1568
1569 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1570 {
1571     int ret = 0, i, got_packet = 0;
1572     AVDictionary *metadata = NULL;
1573
1574     av_init_packet(pkt);
1575
1576     while (!got_packet && !s->internal->parse_queue) {
1577         AVStream *st;
1578         AVPacket cur_pkt;
1579
1580         /* read next packet */
1581         ret = ff_read_packet(s, &cur_pkt);
1582         if (ret < 0) {
1583             if (ret == AVERROR(EAGAIN))
1584                 return ret;
1585             /* flush the parsers */
1586             for (i = 0; i < s->nb_streams; i++) {
1587                 st = s->streams[i];
1588                 if (st->parser && st->need_parsing)
1589                     parse_packet(s, NULL, st->index);
1590             }
1591             /* all remaining packets are now in parse_queue =>
1592              * really terminate parsing */
1593             break;
1594         }
1595         ret = 0;
1596         st  = s->streams[cur_pkt.stream_index];
1597
1598         /* update context if required */
1599         if (st->internal->need_context_update) {
1600             if (avcodec_is_open(st->internal->avctx)) {
1601                 av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
1602                 avcodec_close(st->internal->avctx);
1603                 st->info->found_decoder = 0;
1604             }
1605
1606             /* close parser, because it depends on the codec */
1607             if (st->parser && st->internal->avctx->codec_id != st->codecpar->codec_id) {
1608                 av_parser_close(st->parser);
1609                 st->parser = NULL;
1610             }
1611
1612             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
1613             if (ret < 0)
1614                 return ret;
1615
1616 #if FF_API_LAVF_AVCTX
1617 FF_DISABLE_DEPRECATION_WARNINGS
1618             /* update deprecated public codec context */
1619             ret = avcodec_parameters_to_context(st->codec, st->codecpar);
1620             if (ret < 0)
1621                 return ret;
1622 FF_ENABLE_DEPRECATION_WARNINGS
1623 #endif
1624
1625             st->internal->need_context_update = 0;
1626         }
1627
1628         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1629             cur_pkt.dts != AV_NOPTS_VALUE &&
1630             cur_pkt.pts < cur_pkt.dts) {
1631             av_log(s, AV_LOG_WARNING,
1632                    "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1633                    cur_pkt.stream_index,
1634                    av_ts2str(cur_pkt.pts),
1635                    av_ts2str(cur_pkt.dts),
1636                    cur_pkt.size);
1637         }
1638         if (s->debug & FF_FDEBUG_TS)
1639             av_log(s, AV_LOG_DEBUG,
1640                    "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
1641                    cur_pkt.stream_index,
1642                    av_ts2str(cur_pkt.pts),
1643                    av_ts2str(cur_pkt.dts),
1644                    cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1645
1646         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1647             st->parser = av_parser_init(st->codecpar->codec_id);
1648             if (!st->parser) {
1649                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1650                        "%s, packets or times may be invalid.\n",
1651                        avcodec_get_name(st->codecpar->codec_id));
1652                 /* no parser available: just output the raw packets */
1653                 st->need_parsing = AVSTREAM_PARSE_NONE;
1654             } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1655                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1656             else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1657                 st->parser->flags |= PARSER_FLAG_ONCE;
1658             else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1659                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1660         }
1661
1662         if (!st->need_parsing || !st->parser) {
1663             /* no parsing needed: we just output the packet as is */
1664             *pkt = cur_pkt;
1665             compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1666             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1667                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1668                 ff_reduce_index(s, st->index);
1669                 av_add_index_entry(st, pkt->pos, pkt->dts,
1670                                    0, 0, AVINDEX_KEYFRAME);
1671             }
1672             got_packet = 1;
1673         } else if (st->discard < AVDISCARD_ALL) {
1674             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1675                 return ret;
1676             st->codecpar->sample_rate = st->internal->avctx->sample_rate;
1677             st->codecpar->bit_rate = st->internal->avctx->bit_rate;
1678             st->codecpar->channels = st->internal->avctx->channels;
1679             st->codecpar->channel_layout = st->internal->avctx->channel_layout;
1680             st->codecpar->codec_id = st->internal->avctx->codec_id;
1681         } else {
1682             /* free packet */
1683             av_packet_unref(&cur_pkt);
1684         }
1685         if (pkt->flags & AV_PKT_FLAG_KEY)
1686             st->skip_to_keyframe = 0;
1687         if (st->skip_to_keyframe) {
1688             av_packet_unref(&cur_pkt);
1689             if (got_packet) {
1690                 *pkt = cur_pkt;
1691             }
1692             got_packet = 0;
1693         }
1694     }
1695
1696     if (!got_packet && s->internal->parse_queue)
1697         ret = ff_packet_list_get(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
1698
1699     if (ret >= 0) {
1700         AVStream *st = s->streams[pkt->stream_index];
1701         int discard_padding = 0;
1702         if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1703             int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1704             int64_t sample = ts_to_samples(st, pts);
1705             int duration = ts_to_samples(st, pkt->duration);
1706             int64_t end_sample = sample + duration;
1707             if (duration > 0 && end_sample >= st->first_discard_sample &&
1708                 sample < st->last_discard_sample)
1709                 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1710         }
1711         if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1712             st->skip_samples = st->start_skip_samples;
1713         if (st->skip_samples || discard_padding) {
1714             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1715             if (p) {
1716                 AV_WL32(p, st->skip_samples);
1717                 AV_WL32(p + 4, discard_padding);
1718                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
1719             }
1720             st->skip_samples = 0;
1721         }
1722
1723         if (st->inject_global_side_data) {
1724             for (i = 0; i < st->nb_side_data; i++) {
1725                 AVPacketSideData *src_sd = &st->side_data[i];
1726                 uint8_t *dst_data;
1727
1728                 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1729                     continue;
1730
1731                 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1732                 if (!dst_data) {
1733                     av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1734                     continue;
1735                 }
1736
1737                 memcpy(dst_data, src_sd->data, src_sd->size);
1738             }
1739             st->inject_global_side_data = 0;
1740         }
1741     }
1742
1743     av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1744     if (metadata) {
1745         s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1746         av_dict_copy(&s->metadata, metadata, 0);
1747         av_dict_free(&metadata);
1748         av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1749     }
1750
1751 #if FF_API_LAVF_AVCTX
1752     update_stream_avctx(s);
1753 #endif
1754
1755     if (s->debug & FF_FDEBUG_TS)
1756         av_log(s, AV_LOG_DEBUG,
1757                "read_frame_internal stream=%d, pts=%s, dts=%s, "
1758                "size=%d, duration=%"PRId64", flags=%d\n",
1759                pkt->stream_index,
1760                av_ts2str(pkt->pts),
1761                av_ts2str(pkt->dts),
1762                pkt->size, pkt->duration, pkt->flags);
1763
1764     return ret;
1765 }
1766
1767 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1768 {
1769     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1770     int eof = 0;
1771     int ret;
1772     AVStream *st;
1773
1774     if (!genpts) {
1775         ret = s->internal->packet_buffer
1776               ? ff_packet_list_get(&s->internal->packet_buffer,
1777                                         &s->internal->packet_buffer_end, pkt)
1778               : read_frame_internal(s, pkt);
1779         if (ret < 0)
1780             return ret;
1781         goto return_packet;
1782     }
1783
1784     for (;;) {
1785         AVPacketList *pktl = s->internal->packet_buffer;
1786
1787         if (pktl) {
1788             AVPacket *next_pkt = &pktl->pkt;
1789
1790             if (next_pkt->dts != AV_NOPTS_VALUE) {
1791                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1792                 // last dts seen for this stream. if any of packets following
1793                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1794                 int64_t last_dts = next_pkt->dts;
1795                 av_assert2(wrap_bits <= 64);
1796                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1797                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1798                         av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) {
1799                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) {
1800                             // not B-frame
1801                             next_pkt->pts = pktl->pkt.dts;
1802                         }
1803                         if (last_dts != AV_NOPTS_VALUE) {
1804                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1805                             last_dts = pktl->pkt.dts;
1806                         }
1807                     }
1808                     pktl = pktl->next;
1809                 }
1810                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1811                     // Fixing the last reference frame had none pts issue (For MXF etc).
1812                     // We only do this when
1813                     // 1. eof.
1814                     // 2. we are not able to resolve a pts value for current packet.
1815                     // 3. the packets for this stream at the end of the files had valid dts.
1816                     next_pkt->pts = last_dts + next_pkt->duration;
1817                 }
1818                 pktl = s->internal->packet_buffer;
1819             }
1820
1821             /* read packet from packet buffer, if there is data */
1822             st = s->streams[next_pkt->stream_index];
1823             if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1824                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1825                 ret = ff_packet_list_get(&s->internal->packet_buffer,
1826                                                &s->internal->packet_buffer_end, pkt);
1827                 goto return_packet;
1828             }
1829         }
1830
1831         ret = read_frame_internal(s, pkt);
1832         if (ret < 0) {
1833             if (pktl && ret != AVERROR(EAGAIN)) {
1834                 eof = 1;
1835                 continue;
1836             } else
1837                 return ret;
1838         }
1839
1840         ret = ff_packet_list_put(&s->internal->packet_buffer,
1841                                  &s->internal->packet_buffer_end,
1842                                  pkt, FF_PACKETLIST_FLAG_REF_PACKET);
1843         av_packet_unref(pkt);
1844         if (ret < 0)
1845             return ret;
1846     }
1847
1848 return_packet:
1849
1850     st = s->streams[pkt->stream_index];
1851     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1852         ff_reduce_index(s, st->index);
1853         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1854     }
1855
1856     if (is_relative(pkt->dts))
1857         pkt->dts -= RELATIVE_TS_BASE;
1858     if (is_relative(pkt->pts))
1859         pkt->pts -= RELATIVE_TS_BASE;
1860
1861     return ret;
1862 }
1863
1864 /* XXX: suppress the packet queue */
1865 static void flush_packet_queue(AVFormatContext *s)
1866 {
1867     if (!s->internal)
1868         return;
1869     ff_packet_list_free(&s->internal->parse_queue,       &s->internal->parse_queue_end);
1870     ff_packet_list_free(&s->internal->packet_buffer,     &s->internal->packet_buffer_end);
1871     ff_packet_list_free(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1872
1873     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1874 }
1875
1876 /*******************************************************/
1877 /* seek support */
1878
1879 int av_find_default_stream_index(AVFormatContext *s)
1880 {
1881     int i;
1882     AVStream *st;
1883     int best_stream = 0;
1884     int best_score = INT_MIN;
1885
1886     if (s->nb_streams <= 0)
1887         return -1;
1888     for (i = 0; i < s->nb_streams; i++) {
1889         int score = 0;
1890         st = s->streams[i];
1891         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1892             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
1893                 score -= 400;
1894             if (st->codecpar->width && st->codecpar->height)
1895                 score += 50;
1896             score+= 25;
1897         }
1898         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1899             if (st->codecpar->sample_rate)
1900                 score += 50;
1901         }
1902         if (st->codec_info_nb_frames)
1903             score += 12;
1904
1905         if (st->discard != AVDISCARD_ALL)
1906             score += 200;
1907
1908         if (score > best_score) {
1909             best_score = score;
1910             best_stream = i;
1911         }
1912     }
1913     return best_stream;
1914 }
1915
1916 /** Flush the frame reader. */
1917 void ff_read_frame_flush(AVFormatContext *s)
1918 {
1919     AVStream *st;
1920     int i, j;
1921
1922     flush_packet_queue(s);
1923
1924     /* Reset read state for each stream. */
1925     for (i = 0; i < s->nb_streams; i++) {
1926         st = s->streams[i];
1927
1928         if (st->parser) {
1929             av_parser_close(st->parser);
1930             st->parser = NULL;
1931         }
1932         st->last_IP_pts = AV_NOPTS_VALUE;
1933         st->last_dts_for_order_check = AV_NOPTS_VALUE;
1934         if (st->first_dts == AV_NOPTS_VALUE)
1935             st->cur_dts = RELATIVE_TS_BASE;
1936         else
1937             /* We set the current DTS to an unspecified origin. */
1938             st->cur_dts = AV_NOPTS_VALUE;
1939
1940         st->probe_packets = MAX_PROBE_PACKETS;
1941
1942         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1943             st->pts_buffer[j] = AV_NOPTS_VALUE;
1944
1945         if (s->internal->inject_global_side_data)
1946             st->inject_global_side_data = 1;
1947
1948         st->skip_samples = 0;
1949     }
1950 }
1951
1952 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1953 {
1954     int i;
1955
1956     for (i = 0; i < s->nb_streams; i++) {
1957         AVStream *st = s->streams[i];
1958
1959         st->cur_dts =
1960             av_rescale(timestamp,
1961                        st->time_base.den * (int64_t) ref_st->time_base.num,
1962                        st->time_base.num * (int64_t) ref_st->time_base.den);
1963     }
1964 }
1965
1966 void ff_reduce_index(AVFormatContext *s, int stream_index)
1967 {
1968     AVStream *st             = s->streams[stream_index];
1969     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1970
1971     if ((unsigned) st->nb_index_entries >= max_entries) {
1972         int i;
1973         for (i = 0; 2 * i < st->nb_index_entries; i++)
1974             st->index_entries[i] = st->index_entries[2 * i];
1975         st->nb_index_entries = i;
1976     }
1977 }
1978
1979 int ff_add_index_entry(AVIndexEntry **index_entries,
1980                        int *nb_index_entries,
1981                        unsigned int *index_entries_allocated_size,
1982                        int64_t pos, int64_t timestamp,
1983                        int size, int distance, int flags)
1984 {
1985     AVIndexEntry *entries, *ie;
1986     int index;
1987
1988     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1989         return -1;
1990
1991     if (timestamp == AV_NOPTS_VALUE)
1992         return AVERROR(EINVAL);
1993
1994     if (size < 0 || size > 0x3FFFFFFF)
1995         return AVERROR(EINVAL);
1996
1997     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1998         timestamp -= RELATIVE_TS_BASE;
1999
2000     entries = av_fast_realloc(*index_entries,
2001                               index_entries_allocated_size,
2002                               (*nb_index_entries + 1) *
2003                               sizeof(AVIndexEntry));
2004     if (!entries)
2005         return -1;
2006
2007     *index_entries = entries;
2008
2009     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
2010                                       timestamp, AVSEEK_FLAG_ANY);
2011
2012     if (index < 0) {
2013         index = (*nb_index_entries)++;
2014         ie    = &entries[index];
2015         av_assert0(index == 0 || ie[-1].timestamp < timestamp);
2016     } else {
2017         ie = &entries[index];
2018         if (ie->timestamp != timestamp) {
2019             if (ie->timestamp <= timestamp)
2020                 return -1;
2021             memmove(entries + index + 1, entries + index,
2022                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
2023             (*nb_index_entries)++;
2024         } else if (ie->pos == pos && distance < ie->min_distance)
2025             // do not reduce the distance
2026             distance = ie->min_distance;
2027     }
2028
2029     ie->pos          = pos;
2030     ie->timestamp    = timestamp;
2031     ie->min_distance = distance;
2032     ie->size         = size;
2033     ie->flags        = flags;
2034
2035     return index;
2036 }
2037
2038 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
2039                        int size, int distance, int flags)
2040 {
2041     timestamp = wrap_timestamp(st, timestamp);
2042     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
2043                               &st->index_entries_allocated_size, pos,
2044                               timestamp, size, distance, flags);
2045 }
2046
2047 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
2048                               int64_t wanted_timestamp, int flags)
2049 {
2050     int a, b, m;
2051     int64_t timestamp;
2052
2053     a = -1;
2054     b = nb_entries;
2055
2056     // Optimize appending index entries at the end.
2057     if (b && entries[b - 1].timestamp < wanted_timestamp)
2058         a = b - 1;
2059
2060     while (b - a > 1) {
2061         m         = (a + b) >> 1;
2062
2063         // Search for the next non-discarded packet.
2064         while ((entries[m].flags & AVINDEX_DISCARD_FRAME) && m < b && m < nb_entries - 1) {
2065             m++;
2066             if (m == b && entries[m].timestamp >= wanted_timestamp) {
2067                 m = b - 1;
2068                 break;
2069             }
2070         }
2071
2072         timestamp = entries[m].timestamp;
2073         if (timestamp >= wanted_timestamp)
2074             b = m;
2075         if (timestamp <= wanted_timestamp)
2076             a = m;
2077     }
2078     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
2079
2080     if (!(flags & AVSEEK_FLAG_ANY))
2081         while (m >= 0 && m < nb_entries &&
2082                !(entries[m].flags & AVINDEX_KEYFRAME))
2083             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
2084
2085     if (m == nb_entries)
2086         return -1;
2087     return m;
2088 }
2089
2090 void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
2091 {
2092     int ist1, ist2;
2093     int64_t pos_delta = 0;
2094     int64_t skip = 0;
2095     //We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
2096     const char *proto = avio_find_protocol_name(s->url);
2097
2098     if (!proto) {
2099         av_log(s, AV_LOG_INFO,
2100                "Protocol name not provided, cannot determine if input is local or "
2101                "a network protocol, buffers and access patterns cannot be configured "
2102                "optimally without knowing the protocol\n");
2103     }
2104
2105     if (proto && !(strcmp(proto, "file") && strcmp(proto, "pipe") && strcmp(proto, "cache")))
2106         return;
2107
2108     for (ist1 = 0; ist1 < s->nb_streams; ist1++) {
2109         AVStream *st1 = s->streams[ist1];
2110         for (ist2 = 0; ist2 < s->nb_streams; ist2++) {
2111             AVStream *st2 = s->streams[ist2];
2112             int i1, i2;
2113
2114             if (ist1 == ist2)
2115                 continue;
2116
2117             for (i1 = i2 = 0; i1 < st1->nb_index_entries; i1++) {
2118                 AVIndexEntry *e1 = &st1->index_entries[i1];
2119                 int64_t e1_pts = av_rescale_q(e1->timestamp, st1->time_base, AV_TIME_BASE_Q);
2120
2121                 skip = FFMAX(skip, e1->size);
2122                 for (; i2 < st2->nb_index_entries; i2++) {
2123                     AVIndexEntry *e2 = &st2->index_entries[i2];
2124                     int64_t e2_pts = av_rescale_q(e2->timestamp, st2->time_base, AV_TIME_BASE_Q);
2125                     if (e2_pts - e1_pts < time_tolerance)
2126                         continue;
2127                     pos_delta = FFMAX(pos_delta, e1->pos - e2->pos);
2128                     break;
2129                 }
2130             }
2131         }
2132     }
2133
2134     pos_delta *= 2;
2135     /* XXX This could be adjusted depending on protocol*/
2136     if (s->pb->buffer_size < pos_delta && pos_delta < (1<<24)) {
2137         av_log(s, AV_LOG_VERBOSE, "Reconfiguring buffers to size %"PRId64"\n", pos_delta);
2138         ffio_set_buf_size(s->pb, pos_delta);
2139         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, pos_delta/2);
2140     }
2141
2142     if (skip < (1<<23)) {
2143         s->pb->short_seek_threshold = FFMAX(s->pb->short_seek_threshold, skip);
2144     }
2145 }
2146
2147 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
2148 {
2149     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
2150                                      wanted_timestamp, flags);
2151 }
2152
2153 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
2154                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2155 {
2156     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
2157     if (stream_index >= 0)
2158         ts = wrap_timestamp(s->streams[stream_index], ts);
2159     return ts;
2160 }
2161
2162 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
2163                          int64_t target_ts, int flags)
2164 {
2165     AVInputFormat *avif = s->iformat;
2166     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
2167     int64_t ts_min, ts_max, ts;
2168     int index;
2169     int64_t ret;
2170     AVStream *st;
2171
2172     if (stream_index < 0)
2173         return -1;
2174
2175     av_log(s, AV_LOG_TRACE, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2176
2177     ts_max =
2178     ts_min = AV_NOPTS_VALUE;
2179     pos_limit = -1; // GCC falsely says it may be uninitialized.
2180
2181     st = s->streams[stream_index];
2182     if (st->index_entries) {
2183         AVIndexEntry *e;
2184
2185         /* FIXME: Whole function must be checked for non-keyframe entries in
2186          * index case, especially read_timestamp(). */
2187         index = av_index_search_timestamp(st, target_ts,
2188                                           flags | AVSEEK_FLAG_BACKWARD);
2189         index = FFMAX(index, 0);
2190         e     = &st->index_entries[index];
2191
2192         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
2193             pos_min = e->pos;
2194             ts_min  = e->timestamp;
2195             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
2196                     pos_min, av_ts2str(ts_min));
2197         } else {
2198             av_assert1(index == 0);
2199         }
2200
2201         index = av_index_search_timestamp(st, target_ts,
2202                                           flags & ~AVSEEK_FLAG_BACKWARD);
2203         av_assert0(index < st->nb_index_entries);
2204         if (index >= 0) {
2205             e = &st->index_entries[index];
2206             av_assert1(e->timestamp >= target_ts);
2207             pos_max   = e->pos;
2208             ts_max    = e->timestamp;
2209             pos_limit = pos_max - e->min_distance;
2210             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
2211                     " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
2212         }
2213     }
2214
2215     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
2216                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
2217     if (pos < 0)
2218         return -1;
2219
2220     /* do the seek */
2221     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2222         return ret;
2223
2224     ff_read_frame_flush(s);
2225     ff_update_cur_dts(s, st, ts);
2226
2227     return 0;
2228 }
2229
2230 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
2231                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
2232 {
2233     int64_t step = 1024;
2234     int64_t limit, ts_max;
2235     int64_t filesize = avio_size(s->pb);
2236     int64_t pos_max  = filesize - 1;
2237     do {
2238         limit = pos_max;
2239         pos_max = FFMAX(0, (pos_max) - step);
2240         ts_max  = ff_read_timestamp(s, stream_index,
2241                                     &pos_max, limit, read_timestamp);
2242         step   += step;
2243     } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
2244     if (ts_max == AV_NOPTS_VALUE)
2245         return -1;
2246
2247     for (;;) {
2248         int64_t tmp_pos = pos_max + 1;
2249         int64_t tmp_ts  = ff_read_timestamp(s, stream_index,
2250                                             &tmp_pos, INT64_MAX, read_timestamp);
2251         if (tmp_ts == AV_NOPTS_VALUE)
2252             break;
2253         av_assert0(tmp_pos > pos_max);
2254         ts_max  = tmp_ts;
2255         pos_max = tmp_pos;
2256         if (tmp_pos >= filesize)
2257             break;
2258     }
2259
2260     if (ts)
2261         *ts = ts_max;
2262     if (pos)
2263         *pos = pos_max;
2264
2265     return 0;
2266 }
2267
2268 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
2269                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
2270                       int64_t ts_min, int64_t ts_max,
2271                       int flags, int64_t *ts_ret,
2272                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
2273                                                 int64_t *, int64_t))
2274 {
2275     int64_t pos, ts;
2276     int64_t start_pos;
2277     int no_change;
2278     int ret;
2279
2280     av_log(s, AV_LOG_TRACE, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2281
2282     if (ts_min == AV_NOPTS_VALUE) {
2283         pos_min = s->internal->data_offset;
2284         ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2285         if (ts_min == AV_NOPTS_VALUE)
2286             return -1;
2287     }
2288
2289     if (ts_min >= target_ts) {
2290         *ts_ret = ts_min;
2291         return pos_min;
2292     }
2293
2294     if (ts_max == AV_NOPTS_VALUE) {
2295         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2296             return ret;
2297         pos_limit = pos_max;
2298     }
2299
2300     if (ts_max <= target_ts) {
2301         *ts_ret = ts_max;
2302         return pos_max;
2303     }
2304
2305     av_assert0(ts_min < ts_max);
2306
2307     no_change = 0;
2308     while (pos_min < pos_limit) {
2309         av_log(s, AV_LOG_TRACE,
2310                 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2311                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2312         av_assert0(pos_limit <= pos_max);
2313
2314         if (no_change == 0) {
2315             int64_t approximate_keyframe_distance = pos_max - pos_limit;
2316             // interpolate position (better than dichotomy)
2317             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2318                              ts_max - ts_min) +
2319                   pos_min - approximate_keyframe_distance;
2320         } else if (no_change == 1) {
2321             // bisection if interpolation did not change min / max pos last time
2322             pos = (pos_min + pos_limit) >> 1;
2323         } else {
2324             /* linear search if bisection failed, can only happen if there
2325              * are very few or no keyframes between min/max */
2326             pos = pos_min;
2327         }
2328         if (pos <= pos_min)
2329             pos = pos_min + 1;
2330         else if (pos > pos_limit)
2331             pos = pos_limit;
2332         start_pos = pos;
2333
2334         // May pass pos_limit instead of -1.
2335         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2336         if (pos == pos_max)
2337             no_change++;
2338         else
2339             no_change = 0;
2340         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2341                 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2342                 pos_min, pos, pos_max,
2343                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2344                 pos_limit, start_pos, no_change);
2345         if (ts == AV_NOPTS_VALUE) {
2346             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2347             return -1;
2348         }
2349         if (target_ts <= ts) {
2350             pos_limit = start_pos - 1;
2351             pos_max   = pos;
2352             ts_max    = ts;
2353         }
2354         if (target_ts >= ts) {
2355             pos_min = pos;
2356             ts_min  = ts;
2357         }
2358     }
2359
2360     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2361     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
2362 #if 0
2363     pos_min = pos;
2364     ts_min  = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2365     pos_min++;
2366     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2367     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2368             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2369 #endif
2370     *ts_ret = ts;
2371     return pos;
2372 }
2373
2374 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2375                            int64_t pos, int flags)
2376 {
2377     int64_t pos_min, pos_max;
2378
2379     pos_min = s->internal->data_offset;
2380     pos_max = avio_size(s->pb) - 1;
2381
2382     if (pos < pos_min)
2383         pos = pos_min;
2384     else if (pos > pos_max)
2385         pos = pos_max;
2386
2387     avio_seek(s->pb, pos, SEEK_SET);
2388
2389     s->io_repositioned = 1;
2390
2391     return 0;
2392 }
2393
2394 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2395                               int64_t timestamp, int flags)
2396 {
2397     int index;
2398     int64_t ret;
2399     AVStream *st;
2400     AVIndexEntry *ie;
2401
2402     st = s->streams[stream_index];
2403
2404     index = av_index_search_timestamp(st, timestamp, flags);
2405
2406     if (index < 0 && st->nb_index_entries &&
2407         timestamp < st->index_entries[0].timestamp)
2408         return -1;
2409
2410     if (index < 0 || index == st->nb_index_entries - 1) {
2411         AVPacket pkt;
2412         int nonkey = 0;
2413
2414         if (st->nb_index_entries) {
2415             av_assert0(st->index_entries);
2416             ie = &st->index_entries[st->nb_index_entries - 1];
2417             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2418                 return ret;
2419             ff_update_cur_dts(s, st, ie->timestamp);
2420         } else {
2421             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
2422                 return ret;
2423         }
2424         for (;;) {
2425             int read_status;
2426             do {
2427                 read_status = av_read_frame(s, &pkt);
2428             } while (read_status == AVERROR(EAGAIN));
2429             if (read_status < 0)
2430                 break;
2431             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2432                 if (pkt.flags & AV_PKT_FLAG_KEY) {
2433                     av_packet_unref(&pkt);
2434                     break;
2435                 }
2436                 if (nonkey++ > 1000 && st->codecpar->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2437                     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);
2438                     av_packet_unref(&pkt);
2439                     break;
2440                 }
2441             }
2442             av_packet_unref(&pkt);
2443         }
2444         index = av_index_search_timestamp(st, timestamp, flags);
2445     }
2446     if (index < 0)
2447         return -1;
2448
2449     ff_read_frame_flush(s);
2450     if (s->iformat->read_seek)
2451         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2452             return 0;
2453     ie = &st->index_entries[index];
2454     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2455         return ret;
2456     ff_update_cur_dts(s, st, ie->timestamp);
2457
2458     return 0;
2459 }
2460
2461 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2462                                int64_t timestamp, int flags)
2463 {
2464     int ret;
2465     AVStream *st;
2466
2467     if (flags & AVSEEK_FLAG_BYTE) {
2468         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2469             return -1;
2470         ff_read_frame_flush(s);
2471         return seek_frame_byte(s, stream_index, timestamp, flags);
2472     }
2473
2474     if (stream_index < 0) {
2475         stream_index = av_find_default_stream_index(s);
2476         if (stream_index < 0)
2477             return -1;
2478
2479         st = s->streams[stream_index];
2480         /* timestamp for default must be expressed in AV_TIME_BASE units */
2481         timestamp = av_rescale(timestamp, st->time_base.den,
2482                                AV_TIME_BASE * (int64_t) st->time_base.num);
2483     }
2484
2485     /* first, we try the format specific seek */
2486     if (s->iformat->read_seek) {
2487         ff_read_frame_flush(s);
2488         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2489     } else
2490         ret = -1;
2491     if (ret >= 0)
2492         return 0;
2493
2494     if (s->iformat->read_timestamp &&
2495         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2496         ff_read_frame_flush(s);
2497         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2498     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2499         ff_read_frame_flush(s);
2500         return seek_frame_generic(s, stream_index, timestamp, flags);
2501     } else
2502         return -1;
2503 }
2504
2505 int av_seek_frame(AVFormatContext *s, int stream_index,
2506                   int64_t timestamp, int flags)
2507 {
2508     int ret;
2509
2510     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2511         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2512         if ((flags & AVSEEK_FLAG_BACKWARD))
2513             max_ts = timestamp;
2514         else
2515             min_ts = timestamp;
2516         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2517                                   flags & ~AVSEEK_FLAG_BACKWARD);
2518     }
2519
2520     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2521
2522     if (ret >= 0)
2523         ret = avformat_queue_attached_pictures(s);
2524
2525     return ret;
2526 }
2527
2528 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2529                        int64_t ts, int64_t max_ts, int flags)
2530 {
2531     if (min_ts > ts || max_ts < ts)
2532         return -1;
2533     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2534         return AVERROR(EINVAL);
2535
2536     if (s->seek2any>0)
2537         flags |= AVSEEK_FLAG_ANY;
2538     flags &= ~AVSEEK_FLAG_BACKWARD;
2539
2540     if (s->iformat->read_seek2) {
2541         int ret;
2542         ff_read_frame_flush(s);
2543
2544         if (stream_index == -1 && s->nb_streams == 1) {
2545             AVRational time_base = s->streams[0]->time_base;
2546             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2547             min_ts = av_rescale_rnd(min_ts, time_base.den,
2548                                     time_base.num * (int64_t)AV_TIME_BASE,
2549                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2550             max_ts = av_rescale_rnd(max_ts, time_base.den,
2551                                     time_base.num * (int64_t)AV_TIME_BASE,
2552                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2553             stream_index = 0;
2554         }
2555
2556         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2557                                      ts, max_ts, flags);
2558
2559         if (ret >= 0)
2560             ret = avformat_queue_attached_pictures(s);
2561         return ret;
2562     }
2563
2564     if (s->iformat->read_timestamp) {
2565         // try to seek via read_timestamp()
2566     }
2567
2568     // Fall back on old API if new is not implemented but old is.
2569     // Note the old API has somewhat different semantics.
2570     if (s->iformat->read_seek || 1) {
2571         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2572         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2573         if (ret<0 && ts != min_ts && max_ts != ts) {
2574             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2575             if (ret >= 0)
2576                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2577         }
2578         return ret;
2579     }
2580
2581     // try some generic seek like seek_frame_generic() but with new ts semantics
2582     return -1; //unreachable
2583 }
2584
2585 int avformat_flush(AVFormatContext *s)
2586 {
2587     ff_read_frame_flush(s);
2588     return 0;
2589 }
2590
2591 /*******************************************************/
2592
2593 /**
2594  * Return TRUE if the stream has accurate duration in any stream.
2595  *
2596  * @return TRUE if the stream has accurate duration for at least one component.
2597  */
2598 static int has_duration(AVFormatContext *ic)
2599 {
2600     int i;
2601     AVStream *st;
2602
2603     for (i = 0; i < ic->nb_streams; i++) {
2604         st = ic->streams[i];
2605         if (st->duration != AV_NOPTS_VALUE)
2606             return 1;
2607     }
2608     if (ic->duration != AV_NOPTS_VALUE)
2609         return 1;
2610     return 0;
2611 }
2612
2613 /**
2614  * Estimate the stream timings from the one of each components.
2615  *
2616  * Also computes the global bitrate if possible.
2617  */
2618 static void update_stream_timings(AVFormatContext *ic)
2619 {
2620     int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text;
2621     int64_t duration, duration1, filesize;
2622     int i;
2623     AVStream *st;
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     for (i = 0; i < ic->nb_streams; i++) {
2632         st = ic->streams[i];
2633         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2634             start_time1 = av_rescale_q(st->start_time, st->time_base,
2635                                        AV_TIME_BASE_Q);
2636             if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2637                 if (start_time1 < start_time_text)
2638                     start_time_text = start_time1;
2639             } else
2640                 start_time = FFMIN(start_time, start_time1);
2641             end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2642                                          AV_TIME_BASE_Q,
2643                                          AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2644             if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
2645                 end_time1 += start_time1;
2646                 if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2647                     end_time_text = FFMAX(end_time_text, end_time1);
2648                 else
2649                     end_time = FFMAX(end_time, end_time1);
2650             }
2651             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2652                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2653                     p->start_time = start_time1;
2654                 if (p->end_time < end_time1)
2655                     p->end_time = end_time1;
2656             }
2657         }
2658         if (st->duration != AV_NOPTS_VALUE) {
2659             duration1 = av_rescale_q(st->duration, st->time_base,
2660                                      AV_TIME_BASE_Q);
2661             duration  = FFMAX(duration, duration1);
2662         }
2663     }
2664     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2665         start_time = start_time_text;
2666     else if (start_time > start_time_text)
2667         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2668
2669     if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE)) {
2670         end_time = end_time_text;
2671     } else if (end_time < end_time_text) {
2672         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE);
2673     }
2674
2675     if (start_time != INT64_MAX) {
2676         ic->start_time = start_time;
2677         if (end_time != INT64_MIN) {
2678             if (ic->nb_programs > 1) {
2679                 for (i = 0; i < ic->nb_programs; i++) {
2680                     p = ic->programs[i];
2681                     if (p->start_time != AV_NOPTS_VALUE &&
2682                         p->end_time > p->start_time &&
2683                         p->end_time - (uint64_t)p->start_time <= INT64_MAX)
2684                         duration = FFMAX(duration, p->end_time - p->start_time);
2685                 }
2686             } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
2687                 duration = FFMAX(duration, end_time - start_time);
2688             }
2689         }
2690     }
2691     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2692         ic->duration = duration;
2693     }
2694     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
2695         /* compute the bitrate */
2696         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2697                          (double) ic->duration;
2698         if (bitrate >= 0 && bitrate <= INT64_MAX)
2699             ic->bit_rate = bitrate;
2700     }
2701 }
2702
2703 static void fill_all_stream_timings(AVFormatContext *ic)
2704 {
2705     int i;
2706     AVStream *st;
2707
2708     update_stream_timings(ic);
2709     for (i = 0; i < ic->nb_streams; i++) {
2710         st = ic->streams[i];
2711         if (st->start_time == AV_NOPTS_VALUE) {
2712             if (ic->start_time != AV_NOPTS_VALUE)
2713                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2714                                               st->time_base);
2715             if (ic->duration != AV_NOPTS_VALUE)
2716                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2717                                             st->time_base);
2718         }
2719     }
2720 }
2721
2722 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2723 {
2724     int64_t filesize, duration;
2725     int i, show_warning = 0;
2726     AVStream *st;
2727
2728     /* if bit_rate is already set, we believe it */
2729     if (ic->bit_rate <= 0) {
2730         int64_t bit_rate = 0;
2731         for (i = 0; i < ic->nb_streams; i++) {
2732             st = ic->streams[i];
2733             if (st->codecpar->bit_rate <= 0 && st->internal->avctx->bit_rate > 0)
2734                 st->codecpar->bit_rate = st->internal->avctx->bit_rate;
2735             if (st->codecpar->bit_rate > 0) {
2736                 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
2737                     bit_rate = 0;
2738                     break;
2739                 }
2740                 bit_rate += st->codecpar->bit_rate;
2741             } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2742                 // If we have a videostream with packets but without a bitrate
2743                 // then consider the sum not known
2744                 bit_rate = 0;
2745                 break;
2746             }
2747         }
2748         ic->bit_rate = bit_rate;
2749     }
2750
2751     /* if duration is already set, we believe it */
2752     if (ic->duration == AV_NOPTS_VALUE &&
2753         ic->bit_rate != 0) {
2754         filesize = ic->pb ? avio_size(ic->pb) : 0;
2755         if (filesize > ic->internal->data_offset) {
2756             filesize -= ic->internal->data_offset;
2757             for (i = 0; i < ic->nb_streams; i++) {
2758                 st      = ic->streams[i];
2759                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2760                     && st->duration == AV_NOPTS_VALUE) {
2761                     duration = av_rescale(8 * filesize, st->time_base.den,
2762                                           ic->bit_rate *
2763                                           (int64_t) st->time_base.num);
2764                     st->duration = duration;
2765                     show_warning = 1;
2766                 }
2767             }
2768         }
2769     }
2770     if (show_warning)
2771         av_log(ic, AV_LOG_WARNING,
2772                "Estimating duration from bitrate, this may be inaccurate\n");
2773 }
2774
2775 #define DURATION_MAX_READ_SIZE 250000LL
2776 #define DURATION_MAX_RETRY 6
2777
2778 /* only usable for MPEG-PS streams */
2779 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2780 {
2781     AVPacket pkt1, *pkt = &pkt1;
2782     AVStream *st;
2783     int num, den, read_size, i, ret;
2784     int found_duration = 0;
2785     int is_end;
2786     int64_t filesize, offset, duration;
2787     int retry = 0;
2788
2789     /* flush packet queue */
2790     flush_packet_queue(ic);
2791
2792     for (i = 0; i < ic->nb_streams; i++) {
2793         st = ic->streams[i];
2794         if (st->start_time == AV_NOPTS_VALUE &&
2795             st->first_dts == AV_NOPTS_VALUE &&
2796             st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
2797             av_log(ic, AV_LOG_WARNING,
2798                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2799
2800         if (st->parser) {
2801             av_parser_close(st->parser);
2802             st->parser = NULL;
2803         }
2804     }
2805
2806     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2807     /* estimate the end time (duration) */
2808     /* XXX: may need to support wrapping */
2809     filesize = ic->pb ? avio_size(ic->pb) : 0;
2810     do {
2811         is_end = found_duration;
2812         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2813         if (offset < 0)
2814             offset = 0;
2815
2816         avio_seek(ic->pb, offset, SEEK_SET);
2817         read_size = 0;
2818         for (;;) {
2819             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2820                 break;
2821
2822             do {
2823                 ret = ff_read_packet(ic, pkt);
2824             } while (ret == AVERROR(EAGAIN));
2825             if (ret != 0)
2826                 break;
2827             read_size += pkt->size;
2828             st         = ic->streams[pkt->stream_index];
2829             if (pkt->pts != AV_NOPTS_VALUE &&
2830                 (st->start_time != AV_NOPTS_VALUE ||
2831                  st->first_dts  != AV_NOPTS_VALUE)) {
2832                 if (pkt->duration == 0) {
2833                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2834                     if (den && num) {
2835                         pkt->duration = av_rescale_rnd(1,
2836                                            num * (int64_t) st->time_base.den,
2837                                            den * (int64_t) st->time_base.num,
2838                                            AV_ROUND_DOWN);
2839                     }
2840                 }
2841                 duration = pkt->pts + pkt->duration;
2842                 found_duration = 1;
2843                 if (st->start_time != AV_NOPTS_VALUE)
2844                     duration -= st->start_time;
2845                 else
2846                     duration -= st->first_dts;
2847                 if (duration > 0) {
2848                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2849                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2850                         st->duration = duration;
2851                     st->info->last_duration = duration;
2852                 }
2853             }
2854             av_packet_unref(pkt);
2855         }
2856
2857         /* check if all audio/video streams have valid duration */
2858         if (!is_end) {
2859             is_end = 1;
2860             for (i = 0; i < ic->nb_streams; i++) {
2861                 st = ic->streams[i];
2862                 switch (st->codecpar->codec_type) {
2863                     case AVMEDIA_TYPE_VIDEO:
2864                     case AVMEDIA_TYPE_AUDIO:
2865                         if (st->duration == AV_NOPTS_VALUE)
2866                             is_end = 0;
2867                 }
2868             }
2869         }
2870     } while (!is_end &&
2871              offset &&
2872              ++retry <= DURATION_MAX_RETRY);
2873
2874     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2875
2876     /* warn about audio/video streams which duration could not be estimated */
2877     for (i = 0; i < ic->nb_streams; i++) {
2878         st = ic->streams[i];
2879         if (st->duration == AV_NOPTS_VALUE) {
2880             switch (st->codecpar->codec_type) {
2881             case AVMEDIA_TYPE_VIDEO:
2882             case AVMEDIA_TYPE_AUDIO:
2883                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2884                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2885                 } else
2886                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2887             }
2888         }
2889     }
2890     fill_all_stream_timings(ic);
2891
2892     avio_seek(ic->pb, old_offset, SEEK_SET);
2893     for (i = 0; i < ic->nb_streams; i++) {
2894         int j;
2895
2896         st              = ic->streams[i];
2897         st->cur_dts     = st->first_dts;
2898         st->last_IP_pts = AV_NOPTS_VALUE;
2899         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2900         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2901             st->pts_buffer[j] = AV_NOPTS_VALUE;
2902     }
2903 }
2904
2905 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2906 {
2907     int64_t file_size;
2908
2909     /* get the file size, if possible */
2910     if (ic->iformat->flags & AVFMT_NOFILE) {
2911         file_size = 0;
2912     } else {
2913         file_size = avio_size(ic->pb);
2914         file_size = FFMAX(0, file_size);
2915     }
2916
2917     if ((!strcmp(ic->iformat->name, "mpeg") ||
2918          !strcmp(ic->iformat->name, "mpegts")) &&
2919         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2920         /* get accurate estimate from the PTSes */
2921         estimate_timings_from_pts(ic, old_offset);
2922         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2923     } else if (has_duration(ic)) {
2924         /* at least one component has timings - we use them for all
2925          * the components */
2926         fill_all_stream_timings(ic);
2927         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2928     } else {
2929         /* less precise: use bitrate info */
2930         estimate_timings_from_bit_rate(ic);
2931         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2932     }
2933     update_stream_timings(ic);
2934
2935     {
2936         int i;
2937         AVStream av_unused *st;
2938         for (i = 0; i < ic->nb_streams; i++) {
2939             st = ic->streams[i];
2940             av_log(ic, AV_LOG_TRACE, "stream %d: start_time: %0.3f duration: %0.3f\n", i,
2941                    (double) st->start_time * av_q2d(st->time_base),
2942                    (double) st->duration   * av_q2d(st->time_base));
2943         }
2944         av_log(ic, AV_LOG_TRACE,
2945                 "format: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2946                 (double) ic->start_time / AV_TIME_BASE,
2947                 (double) ic->duration   / AV_TIME_BASE,
2948                 (int64_t)ic->bit_rate / 1000);
2949     }
2950 }
2951
2952 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2953 {
2954     AVCodecContext *avctx = st->internal->avctx;
2955
2956 #define FAIL(errmsg) do {                                         \
2957         if (errmsg_ptr)                                           \
2958             *errmsg_ptr = errmsg;                                 \
2959         return 0;                                                 \
2960     } while (0)
2961
2962     if (   avctx->codec_id == AV_CODEC_ID_NONE
2963         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2964         FAIL("unknown codec");
2965     switch (avctx->codec_type) {
2966     case AVMEDIA_TYPE_AUDIO:
2967         if (!avctx->frame_size && determinable_frame_size(avctx))
2968             FAIL("unspecified frame size");
2969         if (st->info->found_decoder >= 0 &&
2970             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2971             FAIL("unspecified sample format");
2972         if (!avctx->sample_rate)
2973             FAIL("unspecified sample rate");
2974         if (!avctx->channels)
2975             FAIL("unspecified number of channels");
2976         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2977             FAIL("no decodable DTS frames");
2978         break;
2979     case AVMEDIA_TYPE_VIDEO:
2980         if (!avctx->width)
2981             FAIL("unspecified size");
2982         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2983             FAIL("unspecified pixel format");
2984         if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40)
2985             if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2986                 FAIL("no frame in rv30/40 and no sar");
2987         break;
2988     case AVMEDIA_TYPE_SUBTITLE:
2989         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2990             FAIL("unspecified size");
2991         break;
2992     case AVMEDIA_TYPE_DATA:
2993         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2994     }
2995
2996     return 1;
2997 }
2998
2999 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
3000 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
3001                             AVDictionary **options)
3002 {
3003     AVCodecContext *avctx = st->internal->avctx;
3004     const AVCodec *codec;
3005     int got_picture = 1, ret = 0;
3006     AVFrame *frame = av_frame_alloc();
3007     AVSubtitle subtitle;
3008     AVPacket pkt = *avpkt;
3009     int do_skip_frame = 0;
3010     enum AVDiscard skip_frame;
3011
3012     if (!frame)
3013         return AVERROR(ENOMEM);
3014
3015     if (!avcodec_is_open(avctx) &&
3016         st->info->found_decoder <= 0 &&
3017         (st->codecpar->codec_id != -st->info->found_decoder || !st->codecpar->codec_id)) {
3018         AVDictionary *thread_opt = NULL;
3019
3020         codec = find_probe_decoder(s, st, st->codecpar->codec_id);
3021
3022         if (!codec) {
3023             st->info->found_decoder = -st->codecpar->codec_id;
3024             ret                     = -1;
3025             goto fail;
3026         }
3027
3028         /* Force thread count to 1 since the H.264 decoder will not extract
3029          * SPS and PPS to extradata during multi-threaded decoding. */
3030         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
3031         if (s->codec_whitelist)
3032             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
3033         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
3034         if (!options)
3035             av_dict_free(&thread_opt);
3036         if (ret < 0) {
3037             st->info->found_decoder = -avctx->codec_id;
3038             goto fail;
3039         }
3040         st->info->found_decoder = 1;
3041     } else if (!st->info->found_decoder)
3042         st->info->found_decoder = 1;
3043
3044     if (st->info->found_decoder < 0) {
3045         ret = -1;
3046         goto fail;
3047     }
3048
3049     if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
3050         do_skip_frame = 1;
3051         skip_frame = avctx->skip_frame;
3052         avctx->skip_frame = AVDISCARD_ALL;
3053     }
3054
3055     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
3056            ret >= 0 &&
3057            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
3058             (!st->codec_info_nb_frames &&
3059              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
3060         got_picture = 0;
3061         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
3062             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3063             ret = avcodec_send_packet(avctx, &pkt);
3064             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3065                 break;
3066             if (ret >= 0)
3067                 pkt.size = 0;
3068             ret = avcodec_receive_frame(avctx, frame);
3069             if (ret >= 0)
3070                 got_picture = 1;
3071             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
3072                 ret = 0;
3073         } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3074             ret = avcodec_decode_subtitle2(avctx, &subtitle,
3075                                            &got_picture, &pkt);
3076             if (ret >= 0)
3077                 pkt.size = 0;
3078         }
3079         if (ret >= 0) {
3080             if (got_picture)
3081                 st->nb_decoded_frames++;
3082             ret       = got_picture;
3083         }
3084     }
3085
3086     if (!pkt.data && !got_picture)
3087         ret = -1;
3088
3089 fail:
3090     if (do_skip_frame) {
3091         avctx->skip_frame = skip_frame;
3092     }
3093
3094     av_frame_free(&frame);
3095     return ret;
3096 }
3097
3098 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
3099 {
3100     while (tags->id != AV_CODEC_ID_NONE) {
3101         if (tags->id == id)
3102             return tags->tag;
3103         tags++;
3104     }
3105     return 0;
3106 }
3107
3108 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
3109 {
3110     int i;
3111     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3112         if (tag == tags[i].tag)
3113             return tags[i].id;
3114     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
3115         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
3116             return tags[i].id;
3117     return AV_CODEC_ID_NONE;
3118 }
3119
3120 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
3121 {
3122     if (bps <= 0 || bps > 64)
3123         return AV_CODEC_ID_NONE;
3124
3125     if (flt) {
3126         switch (bps) {
3127         case 32:
3128             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
3129         case 64:
3130             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
3131         default:
3132             return AV_CODEC_ID_NONE;
3133         }
3134     } else {
3135         bps  += 7;
3136         bps >>= 3;
3137         if (sflags & (1 << (bps - 1))) {
3138             switch (bps) {
3139             case 1:
3140                 return AV_CODEC_ID_PCM_S8;
3141             case 2:
3142                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
3143             case 3:
3144                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
3145             case 4:
3146                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
3147             case 8:
3148                 return be ? AV_CODEC_ID_PCM_S64BE : AV_CODEC_ID_PCM_S64LE;
3149             default:
3150                 return AV_CODEC_ID_NONE;
3151             }
3152         } else {
3153             switch (bps) {
3154             case 1:
3155                 return AV_CODEC_ID_PCM_U8;
3156             case 2:
3157                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
3158             case 3:
3159                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
3160             case 4:
3161                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
3162             default:
3163                 return AV_CODEC_ID_NONE;
3164             }
3165         }
3166     }
3167 }
3168
3169 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
3170 {
3171     unsigned int tag;
3172     if (!av_codec_get_tag2(tags, id, &tag))
3173         return 0;
3174     return tag;
3175 }
3176
3177 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
3178                       unsigned int *tag)
3179 {
3180     int i;
3181     for (i = 0; tags && tags[i]; i++) {
3182         const AVCodecTag *codec_tags = tags[i];
3183         while (codec_tags->id != AV_CODEC_ID_NONE) {
3184             if (codec_tags->id == id) {
3185                 *tag = codec_tags->tag;
3186                 return 1;
3187             }
3188             codec_tags++;
3189         }
3190     }
3191     return 0;
3192 }
3193
3194 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
3195 {
3196     int i;
3197     for (i = 0; tags && tags[i]; i++) {
3198         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
3199         if (id != AV_CODEC_ID_NONE)
3200             return id;
3201     }
3202     return AV_CODEC_ID_NONE;
3203 }
3204
3205 static void compute_chapters_end(AVFormatContext *s)
3206 {
3207     unsigned int i, j;
3208     int64_t max_time = 0;
3209
3210     if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
3211         max_time = s->duration +
3212                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
3213
3214     for (i = 0; i < s->nb_chapters; i++)
3215         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
3216             AVChapter *ch = s->chapters[i];
3217             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
3218                                                   ch->time_base)
3219                                    : INT64_MAX;
3220
3221             for (j = 0; j < s->nb_chapters; j++) {
3222                 AVChapter *ch1     = s->chapters[j];
3223                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
3224                                                   ch->time_base);
3225                 if (j != i && next_start > ch->start && next_start < end)
3226                     end = next_start;
3227             }
3228             ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end;
3229         }
3230 }
3231
3232 static int get_std_framerate(int i)
3233 {
3234     if (i < 30*12)
3235         return (i + 1) * 1001;
3236     i -= 30*12;
3237
3238     if (i < 30)
3239         return (i + 31) * 1001 * 12;
3240     i -= 30;
3241
3242     if (i < 3)
3243         return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
3244
3245     i -= 3;
3246
3247     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
3248 }
3249
3250 /* Is the time base unreliable?
3251  * This is a heuristic to balance between quick acceptance of the values in
3252  * the headers vs. some extra checks.
3253  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
3254  * MPEG-2 commonly misuses field repeat flags to store different framerates.
3255  * And there are "variable" fps files this needs to detect as well. */
3256 static int tb_unreliable(AVCodecContext *c)
3257 {
3258     if (c->time_base.den >= 101LL * c->time_base.num ||
3259         c->time_base.den <    5LL * c->time_base.num ||
3260         // c->codec_tag == AV_RL32("DIVX") ||
3261         // c->codec_tag == AV_RL32("XVID") ||
3262         c->codec_tag == AV_RL32("mp4v") ||
3263         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
3264         c->codec_id == AV_CODEC_ID_GIF ||
3265         c->codec_id == AV_CODEC_ID_HEVC ||
3266         c->codec_id == AV_CODEC_ID_H264)
3267         return 1;
3268     return 0;
3269 }
3270
3271 int ff_alloc_extradata(AVCodecParameters *par, int size)
3272 {
3273     av_freep(&par->extradata);
3274     par->extradata_size = 0;
3275
3276     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
3277         return AVERROR(EINVAL);
3278
3279     par->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
3280     if (!par->extradata)
3281         return AVERROR(ENOMEM);
3282
3283     memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
3284     par->extradata_size = size;
3285
3286     return 0;
3287 }
3288
3289 int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
3290 {
3291     int ret = ff_alloc_extradata(par, size);
3292     if (ret < 0)
3293         return ret;
3294     ret = avio_read(pb, par->extradata, size);
3295     if (ret != size) {
3296         av_freep(&par->extradata);
3297         par->extradata_size = 0;
3298         av_log(s, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
3299         return ret < 0 ? ret : AVERROR_INVALIDDATA;
3300     }
3301
3302     return ret;
3303 }
3304
3305 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
3306 {
3307     int i, j;
3308     int64_t last = st->info->last_dts;
3309
3310     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
3311        && ts - (uint64_t)last < INT64_MAX) {
3312         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3313         int64_t duration = ts - last;
3314
3315         if (!st->info->duration_error)
3316             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3317         if (!st->info->duration_error)
3318             return AVERROR(ENOMEM);
3319
3320 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3321 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3322         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3323             if (st->info->duration_error[0][1][i] < 1e10) {
3324                 int framerate = get_std_framerate(i);
3325                 double sdts = dts*framerate/(1001*12);
3326                 for (j= 0; j<2; j++) {
3327                     int64_t ticks = llrint(sdts+j*0.5);
3328                     double error= sdts - ticks + j*0.5;
3329                     st->info->duration_error[j][0][i] += error;
3330                     st->info->duration_error[j][1][i] += error*error;
3331                 }
3332             }
3333         }
3334         st->info->duration_count++;
3335         st->info->rfps_duration_sum += duration;
3336
3337         if (st->info->duration_count % 10 == 0) {
3338             int n = st->info->duration_count;
3339             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3340                 if (st->info->duration_error[0][1][i] < 1e10) {
3341                     double a0     = st->info->duration_error[0][0][i] / n;
3342                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3343                     double a1     = st->info->duration_error[1][0][i] / n;
3344                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3345                     if (error0 > 0.04 && error1 > 0.04) {
3346                         st->info->duration_error[0][1][i] = 2e10;
3347                         st->info->duration_error[1][1][i] = 2e10;
3348                     }
3349                 }
3350             }
3351         }
3352
3353         // ignore the first 4 values, they might have some random jitter
3354         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3355             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3356     }
3357     if (ts != AV_NOPTS_VALUE)
3358         st->info->last_dts = ts;
3359
3360     return 0;
3361 }
3362
3363 void ff_rfps_calculate(AVFormatContext *ic)
3364 {
3365     int i, j;
3366
3367     for (i = 0; i < ic->nb_streams; i++) {
3368         AVStream *st = ic->streams[i];
3369
3370         if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
3371             continue;
3372         // the check for tb_unreliable() is not completely correct, since this is not about handling
3373         // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3374         // ipmovie.c produces.
3375         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)
3376             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);
3377         if (st->info->duration_count>1 && !st->r_frame_rate.num
3378             && tb_unreliable(st->internal->avctx)) {
3379             int num = 0;
3380             double best_error= 0.01;
3381             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3382
3383             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3384                 int k;
3385
3386                 if (st->info->codec_info_duration &&
3387                     st->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
3388                     continue;
3389                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3390                     continue;
3391
3392                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3393                     continue;
3394
3395                 for (k= 0; k<2; k++) {
3396                     int n = st->info->duration_count;
3397                     double a= st->info->duration_error[k][0][j] / n;
3398                     double error= st->info->duration_error[k][1][j]/n - a*a;
3399
3400                     if (error < best_error && best_error> 0.000000001) {
3401                         best_error= error;
3402                         num = get_std_framerate(j);
3403                     }
3404                     if (error < 0.02)
3405                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3406                 }
3407             }
3408             // do not increase frame rate by more than 1 % in order to match a standard rate.
3409             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3410                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3411         }
3412         if (   !st->avg_frame_rate.num
3413             && st->r_frame_rate.num && st->info->rfps_duration_sum
3414             && st->info->codec_info_duration <= 0
3415             && st->info->duration_count > 2
3416             && 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
3417             ) {
3418             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3419             st->avg_frame_rate = st->r_frame_rate;
3420         }
3421
3422         av_freep(&st->info->duration_error);
3423         st->info->last_dts = AV_NOPTS_VALUE;
3424         st->info->duration_count = 0;
3425         st->info->rfps_duration_sum = 0;
3426     }
3427 }
3428
3429 static int extract_extradata_check(AVStream *st)
3430 {
3431     const AVBitStreamFilter *f;
3432
3433     f = av_bsf_get_by_name("extract_extradata");
3434     if (!f)
3435         return 0;
3436
3437     if (f->codec_ids) {
3438         const enum AVCodecID *ids;
3439         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
3440             if (*ids == st->codecpar->codec_id)
3441                 return 1;
3442     }
3443
3444     return 0;
3445 }
3446
3447 static int extract_extradata_init(AVStream *st)
3448 {
3449     AVStreamInternal *i = st->internal;
3450     const AVBitStreamFilter *f;
3451     int ret;
3452
3453     f = av_bsf_get_by_name("extract_extradata");
3454     if (!f)
3455         goto finish;
3456
3457     /* check that the codec id is supported */
3458     ret = extract_extradata_check(st);
3459     if (!ret)
3460         goto finish;
3461
3462     i->extract_extradata.pkt = av_packet_alloc();
3463     if (!i->extract_extradata.pkt)
3464         return AVERROR(ENOMEM);
3465
3466     ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
3467     if (ret < 0)
3468         goto fail;
3469
3470     ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
3471                                   st->codecpar);
3472     if (ret < 0)
3473         goto fail;
3474
3475     i->extract_extradata.bsf->time_base_in = st->time_base;
3476
3477     /* if init fails here, we assume extracting extradata is just not
3478      * supported for this codec, so we return success */
3479     ret = av_bsf_init(i->extract_extradata.bsf);
3480     if (ret < 0) {
3481         av_bsf_free(&i->extract_extradata.bsf);
3482         ret = 0;
3483     }
3484
3485 finish:
3486     i->extract_extradata.inited = 1;
3487
3488     return 0;
3489 fail:
3490     av_bsf_free(&i->extract_extradata.bsf);
3491     av_packet_free(&i->extract_extradata.pkt);
3492     return ret;
3493 }
3494
3495 static int extract_extradata(AVStream *st, AVPacket *pkt)
3496 {
3497     AVStreamInternal *i = st->internal;
3498     AVPacket *pkt_ref;
3499     int ret;
3500
3501     if (!i->extract_extradata.inited) {
3502         ret = extract_extradata_init(st);
3503         if (ret < 0)
3504             return ret;
3505     }
3506
3507     if (i->extract_extradata.inited && !i->extract_extradata.bsf)
3508         return 0;
3509
3510     pkt_ref = i->extract_extradata.pkt;
3511     ret = av_packet_ref(pkt_ref, pkt);
3512     if (ret < 0)
3513         return ret;
3514
3515     ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
3516     if (ret < 0) {
3517         av_packet_unref(pkt_ref);
3518         return ret;
3519     }
3520
3521     while (ret >= 0 && !i->avctx->extradata) {
3522         int extradata_size;
3523         uint8_t *extradata;
3524
3525         ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
3526         if (ret < 0) {
3527             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3528                 return ret;
3529             continue;
3530         }
3531
3532         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3533                                             &extradata_size);
3534
3535         if (extradata) {
3536             i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3537             if (!i->avctx->extradata) {
3538                 av_packet_unref(pkt_ref);
3539                 return AVERROR(ENOMEM);
3540             }
3541             memcpy(i->avctx->extradata, extradata, extradata_size);
3542             i->avctx->extradata_size = extradata_size;
3543         }
3544         av_packet_unref(pkt_ref);
3545     }
3546
3547     return 0;
3548 }
3549
3550 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3551 {
3552     int i, count = 0, ret = 0, j;
3553     int64_t read_size;
3554     AVStream *st;
3555     AVCodecContext *avctx;
3556     AVPacket pkt1, *pkt;
3557     int64_t old_offset  = avio_tell(ic->pb);
3558     // new streams might appear, no options for those
3559     int orig_nb_streams = ic->nb_streams;
3560     int flush_codecs;
3561     int64_t max_analyze_duration = ic->max_analyze_duration;
3562     int64_t max_stream_analyze_duration;
3563     int64_t max_subtitle_analyze_duration;
3564     int64_t probesize = ic->probesize;
3565     int eof_reached = 0;
3566     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3567
3568     flush_codecs = probesize > 0;
3569
3570     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3571
3572     max_stream_analyze_duration = max_analyze_duration;
3573     max_subtitle_analyze_duration = max_analyze_duration;
3574     if (!max_analyze_duration) {
3575         max_stream_analyze_duration =
3576         max_analyze_duration        = 5*AV_TIME_BASE;
3577         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3578         if (!strcmp(ic->iformat->name, "flv"))
3579             max_stream_analyze_duration = 90*AV_TIME_BASE;
3580         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3581             max_stream_analyze_duration = 7*AV_TIME_BASE;
3582     }
3583
3584     if (ic->pb)
3585         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3586                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3587
3588     for (i = 0; i < ic->nb_streams; i++) {
3589         const AVCodec *codec;
3590         AVDictionary *thread_opt = NULL;
3591         st = ic->streams[i];
3592         avctx = st->internal->avctx;
3593
3594         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3595             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3596 /*            if (!st->time_base.num)
3597                 st->time_base = */
3598             if (!avctx->time_base.num)
3599                 avctx->time_base = st->time_base;
3600         }
3601
3602         /* check if the caller has overridden the codec id */
3603 #if FF_API_LAVF_AVCTX
3604 FF_DISABLE_DEPRECATION_WARNINGS
3605         if (st->codec->codec_id != st->internal->orig_codec_id) {
3606             st->codecpar->codec_id   = st->codec->codec_id;
3607             st->codecpar->codec_type = st->codec->codec_type;
3608             st->internal->orig_codec_id = st->codec->codec_id;
3609         }
3610 FF_ENABLE_DEPRECATION_WARNINGS
3611 #endif
3612         // only for the split stuff
3613         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3614             st->parser = av_parser_init(st->codecpar->codec_id);
3615             if (st->parser) {
3616                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3617                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3618                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3619                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3620                 }
3621             } else if (st->need_parsing) {
3622                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3623                        "%s, packets or times may be invalid.\n",
3624                        avcodec_get_name(st->codecpar->codec_id));
3625             }
3626         }
3627
3628         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3629             st->internal->orig_codec_id = st->codecpar->codec_id;
3630
3631         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3632         if (ret < 0)
3633             goto find_stream_info_err;
3634         if (st->request_probe <= 0)
3635             st->internal->avctx_inited = 1;
3636
3637         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3638
3639         /* Force thread count to 1 since the H.264 decoder will not extract
3640          * SPS and PPS to extradata during multi-threaded decoding. */
3641         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3642
3643         if (ic->codec_whitelist)
3644             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3645
3646         /* Ensure that subtitle_header is properly set. */
3647         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3648             && codec && !avctx->codec) {
3649             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3650                 av_log(ic, AV_LOG_WARNING,
3651                        "Failed to open codec in %s\n",__FUNCTION__);
3652         }
3653
3654         // Try to just open decoders, in case this is enough to get parameters.
3655         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3656             if (codec && !avctx->codec)
3657                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3658                     av_log(ic, AV_LOG_WARNING,
3659                            "Failed to open codec in %s\n",__FUNCTION__);
3660         }
3661         if (!options)
3662             av_dict_free(&thread_opt);
3663     }
3664
3665     for (i = 0; i < ic->nb_streams; i++) {
3666 #if FF_API_R_FRAME_RATE
3667         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3668 #endif
3669         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3670         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3671     }
3672
3673     read_size = 0;
3674     for (;;) {
3675         int analyzed_all_streams;
3676         if (ff_check_interrupt(&ic->interrupt_callback)) {
3677             ret = AVERROR_EXIT;
3678             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3679             break;
3680         }
3681
3682         /* check if one codec still needs to be handled */
3683         for (i = 0; i < ic->nb_streams; i++) {
3684             int fps_analyze_framecount = 20;
3685             int count;
3686
3687             st = ic->streams[i];
3688             if (!has_codec_parameters(st, NULL))
3689                 break;
3690             /* If the timebase is coarse (like the usual millisecond precision
3691              * of mkv), we need to analyze more frames to reliably arrive at
3692              * the correct fps. */
3693             if (av_q2d(st->time_base) > 0.0005)
3694                 fps_analyze_framecount *= 2;
3695             if (!tb_unreliable(st->internal->avctx))
3696                 fps_analyze_framecount = 0;
3697             if (ic->fps_probe_size >= 0)
3698                 fps_analyze_framecount = ic->fps_probe_size;
3699             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3700                 fps_analyze_framecount = 0;
3701             /* variable fps and no guess at the real fps */
3702             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3703                        st->info->codec_info_duration_fields/2 :
3704                        st->info->duration_count;
3705             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3706                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3707                 if (count < fps_analyze_framecount)
3708                     break;
3709             }
3710             // Look at the first 3 frames if there is evidence of frame delay
3711             // but the decoder delay is not set.
3712             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3713                 break;
3714             if (!st->internal->avctx->extradata &&
3715                 (!st->internal->extract_extradata.inited ||
3716                  st->internal->extract_extradata.bsf) &&
3717                 extract_extradata_check(st))
3718                 break;
3719             if (st->first_dts == AV_NOPTS_VALUE &&
3720                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3721                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3722                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3723                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3724                 break;
3725         }
3726         analyzed_all_streams = 0;
3727         if (!missing_streams || !*missing_streams)
3728         if (i == ic->nb_streams) {
3729             analyzed_all_streams = 1;
3730             /* NOTE: If the format has no header, then we need to read some
3731              * packets to get most of the streams, so we cannot stop here. */
3732             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3733                 /* If we found the info for all the codecs, we can stop. */
3734                 ret = count;
3735                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3736                 flush_codecs = 0;
3737                 break;
3738             }
3739         }
3740         /* We did not get all the codec info, but we read too much data. */
3741         if (read_size >= probesize) {
3742             ret = count;
3743             av_log(ic, AV_LOG_DEBUG,
3744                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3745             for (i = 0; i < ic->nb_streams; i++)
3746                 if (!ic->streams[i]->r_frame_rate.num &&
3747                     ic->streams[i]->info->duration_count <= 1 &&
3748                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3749                     strcmp(ic->iformat->name, "image2"))
3750                     av_log(ic, AV_LOG_WARNING,
3751                            "Stream #%d: not enough frames to estimate rate; "
3752                            "consider increasing probesize\n", i);
3753             break;
3754         }
3755
3756         /* NOTE: A new stream can be added there if no header in file
3757          * (AVFMTCTX_NOHEADER). */
3758         ret = read_frame_internal(ic, &pkt1);
3759         if (ret == AVERROR(EAGAIN))
3760             continue;
3761
3762         if (ret < 0) {
3763             /* EOF or error*/
3764             eof_reached = 1;
3765             break;
3766         }
3767
3768         pkt = &pkt1;
3769
3770         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3771             ret = ff_packet_list_put(&ic->internal->packet_buffer,
3772                                      &ic->internal->packet_buffer_end,
3773                                      pkt, 0);
3774             if (ret < 0)
3775                 goto find_stream_info_err;
3776         }
3777
3778         st = ic->streams[pkt->stream_index];
3779         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3780             read_size += pkt->size;
3781
3782         avctx = st->internal->avctx;
3783         if (!st->internal->avctx_inited) {
3784             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3785             if (ret < 0)
3786                 goto find_stream_info_err;
3787             st->internal->avctx_inited = 1;
3788         }
3789
3790         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3791             /* check for non-increasing dts */
3792             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3793                 st->info->fps_last_dts >= pkt->dts) {
3794                 av_log(ic, AV_LOG_DEBUG,
3795                        "Non-increasing DTS in stream %d: packet %d with DTS "
3796                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3797                        st->index, st->info->fps_last_dts_idx,
3798                        st->info->fps_last_dts, st->codec_info_nb_frames,
3799                        pkt->dts);
3800                 st->info->fps_first_dts =
3801                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3802             }
3803             /* Check for a discontinuity in dts. If the difference in dts
3804              * is more than 1000 times the average packet duration in the
3805              * sequence, we treat it as a discontinuity. */
3806             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3807                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3808                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3809                 (st->info->fps_last_dts     - (uint64_t)st->info->fps_first_dts) /
3810                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3811                 av_log(ic, AV_LOG_WARNING,
3812                        "DTS discontinuity 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
3821             /* update stored dts values */
3822             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3823                 st->info->fps_first_dts     = pkt->dts;
3824                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3825             }
3826             st->info->fps_last_dts     = pkt->dts;
3827             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3828         }
3829         if (st->codec_info_nb_frames>1) {
3830             int64_t t = 0;
3831             int64_t limit;
3832
3833             if (st->time_base.den > 0)
3834                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3835             if (st->avg_frame_rate.num > 0)
3836                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3837
3838             if (   t == 0
3839                 && st->codec_info_nb_frames>30
3840                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3841                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3842                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3843
3844             if (analyzed_all_streams)                                limit = max_analyze_duration;
3845             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3846             else                                                     limit = max_stream_analyze_duration;
3847
3848             if (t >= limit) {
3849                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3850                        limit,
3851                        t, pkt->stream_index);
3852                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3853                     av_packet_unref(pkt);
3854                 break;
3855             }
3856             if (pkt->duration) {
3857                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3858                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3859                 } else
3860                     st->info->codec_info_duration += pkt->duration;
3861                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3862             }
3863         }
3864         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3865 #if FF_API_R_FRAME_RATE
3866             ff_rfps_add_frame(ic, st, pkt->dts);
3867 #endif
3868             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3869                 st->info->frame_delay_evidence = 1;
3870         }
3871         if (!st->internal->avctx->extradata) {
3872             ret = extract_extradata(st, pkt);
3873             if (ret < 0)
3874                 goto find_stream_info_err;
3875         }
3876
3877         /* If still no information, we try to open the codec and to
3878          * decompress the frame. We try to avoid that in most cases as
3879          * it takes longer and uses more memory. For MPEG-4, we need to
3880          * decompress for QuickTime.
3881          *
3882          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3883          * least one frame of codec data, this makes sure the codec initializes
3884          * the channel configuration and does not only trust the values from
3885          * the container. */
3886         try_decode_frame(ic, st, pkt,
3887                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3888
3889         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3890             av_packet_unref(pkt);
3891
3892         st->codec_info_nb_frames++;
3893         count++;
3894     }
3895
3896     if (eof_reached) {
3897         int stream_index;
3898         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3899             st = ic->streams[stream_index];
3900             avctx = st->internal->avctx;
3901             if (!has_codec_parameters(st, NULL)) {
3902                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3903                 if (codec && !avctx->codec) {
3904                     AVDictionary *opts = NULL;
3905                     if (ic->codec_whitelist)
3906                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3907                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3908                         av_log(ic, AV_LOG_WARNING,
3909                                "Failed to open codec in %s\n",__FUNCTION__);
3910                     av_dict_free(&opts);
3911                 }
3912             }
3913
3914             // EOF already reached while reading the stream above.
3915             // So continue with reoordering DTS with whatever delay we have.
3916             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3917                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3918             }
3919         }
3920     }
3921
3922     if (flush_codecs) {
3923         AVPacket empty_pkt = { 0 };
3924         int err = 0;
3925         av_init_packet(&empty_pkt);
3926
3927         for (i = 0; i < ic->nb_streams; i++) {
3928
3929             st = ic->streams[i];
3930
3931             /* flush the decoders */
3932             if (st->info->found_decoder == 1) {
3933                 do {
3934                     err = try_decode_frame(ic, st, &empty_pkt,
3935                                             (options && i < orig_nb_streams)
3936                                             ? &options[i] : NULL);
3937                 } while (err > 0 && !has_codec_parameters(st, NULL));
3938
3939                 if (err < 0) {
3940                     av_log(ic, AV_LOG_INFO,
3941                         "decoding for stream %d failed\n", st->index);
3942                 }
3943             }
3944         }
3945     }
3946
3947     ff_rfps_calculate(ic);
3948
3949     for (i = 0; i < ic->nb_streams; i++) {
3950         st = ic->streams[i];
3951         avctx = st->internal->avctx;
3952         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3953             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3954                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3955                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
3956                     avctx->codec_tag= tag;
3957             }
3958
3959             /* estimate average framerate if not set by demuxer */
3960             if (st->info->codec_info_duration_fields &&
3961                 !st->avg_frame_rate.num &&
3962                 st->info->codec_info_duration) {
3963                 int best_fps      = 0;
3964                 double best_error = 0.01;
3965                 AVRational codec_frame_rate = avctx->framerate;
3966
3967                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3968                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3969                     st->info->codec_info_duration        < 0)
3970                     continue;
3971                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3972                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3973                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3974
3975                 /* Round guessed framerate to a "standard" framerate if it's
3976                  * within 1% of the original estimate. */
3977                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3978                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3979                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3980                                               av_q2d(std_fps) - 1);
3981
3982                     if (error < best_error) {
3983                         best_error = error;
3984                         best_fps   = std_fps.num;
3985                     }
3986
3987                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3988                         error       = fabs(av_q2d(codec_frame_rate) /
3989                                            av_q2d(std_fps) - 1);
3990                         if (error < best_error) {
3991                             best_error = error;
3992                             best_fps   = std_fps.num;
3993                         }
3994                     }
3995                 }
3996                 if (best_fps)
3997                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3998                               best_fps, 12 * 1001, INT_MAX);
3999             }
4000
4001             if (!st->r_frame_rate.num) {
4002                 if (    avctx->time_base.den * (int64_t) st->time_base.num
4003                     <= avctx->time_base.num * avctx->ticks_per_frame * (int64_t) st->time_base.den) {
4004                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4005                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4006                 } else {
4007                     st->r_frame_rate.num = st->time_base.den;
4008                     st->r_frame_rate.den = st->time_base.num;
4009                 }
4010             }
4011             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
4012                 AVRational hw_ratio = { avctx->height, avctx->width };
4013                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
4014                                                    hw_ratio);
4015             }
4016         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4017             if (!avctx->bits_per_coded_sample)
4018                 avctx->bits_per_coded_sample =
4019                     av_get_bits_per_sample(avctx->codec_id);
4020             // set stream disposition based on audio service type
4021             switch (avctx->audio_service_type) {
4022             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4023                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4024                 break;
4025             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4026                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4027                 break;
4028             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4029                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4030                 break;
4031             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4032                 st->disposition = AV_DISPOSITION_COMMENT;
4033                 break;
4034             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4035                 st->disposition = AV_DISPOSITION_KARAOKE;
4036                 break;
4037             }
4038         }
4039     }
4040
4041     if (probesize)
4042         estimate_timings(ic, old_offset);
4043
4044     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4045
4046     if (ret >= 0 && ic->nb_streams)
4047         /* We could not have all the codec parameters before EOF. */
4048         ret = -1;
4049     for (i = 0; i < ic->nb_streams; i++) {
4050         const char *errmsg;
4051         st = ic->streams[i];
4052
4053         /* if no packet was ever seen, update context now for has_codec_parameters */
4054         if (!st->internal->avctx_inited) {
4055             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4056                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4057                 st->codecpar->format = st->internal->avctx->sample_fmt;
4058             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4059             if (ret < 0)
4060                 goto find_stream_info_err;
4061         }
4062         if (!has_codec_parameters(st, &errmsg)) {
4063             char buf[256];
4064             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4065             av_log(ic, AV_LOG_WARNING,
4066                    "Could not find codec parameters for stream %d (%s): %s\n"
4067                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
4068                    i, buf, errmsg);
4069         } else {
4070             ret = 0;
4071         }
4072     }
4073
4074     compute_chapters_end(ic);
4075
4076     /* update the stream parameters from the internal codec contexts */
4077     for (i = 0; i < ic->nb_streams; i++) {
4078         st = ic->streams[i];
4079
4080         if (st->internal->avctx_inited) {
4081             int orig_w = st->codecpar->width;
4082             int orig_h = st->codecpar->height;
4083             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4084             if (ret < 0)
4085                 goto find_stream_info_err;
4086 #if FF_API_LOWRES
4087             // The decoder might reduce the video size by the lowres factor.
4088             if (st->internal->avctx->lowres && orig_w) {
4089                 st->codecpar->width = orig_w;
4090                 st->codecpar->height = orig_h;
4091             }
4092 #endif
4093         }
4094
4095 #if FF_API_LAVF_AVCTX
4096 FF_DISABLE_DEPRECATION_WARNINGS
4097         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4098         if (ret < 0)
4099             goto find_stream_info_err;
4100
4101 #if FF_API_LOWRES
4102         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4103         // by the lowres factor.
4104         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4105             st->codec->lowres = st->internal->avctx->lowres;
4106             st->codec->width = st->internal->avctx->width;
4107             st->codec->height = st->internal->avctx->height;
4108         }
4109 #endif
4110
4111         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4112             st->codec->time_base = st->internal->avctx->time_base;
4113             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4114         }
4115         st->codec->framerate = st->avg_frame_rate;
4116
4117         if (st->internal->avctx->subtitle_header) {
4118             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4119             if (!st->codec->subtitle_header)
4120                 goto find_stream_info_err;
4121             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4122             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4123                    st->codec->subtitle_header_size);
4124         }
4125
4126         // Fields unavailable in AVCodecParameters
4127         st->codec->coded_width = st->internal->avctx->coded_width;
4128         st->codec->coded_height = st->internal->avctx->coded_height;
4129         st->codec->properties = st->internal->avctx->properties;
4130 FF_ENABLE_DEPRECATION_WARNINGS
4131 #endif
4132
4133         st->internal->avctx_inited = 0;
4134     }
4135
4136 find_stream_info_err:
4137     for (i = 0; i < ic->nb_streams; i++) {
4138         st = ic->streams[i];
4139         if (st->info)
4140             av_freep(&st->info->duration_error);
4141         avcodec_close(ic->streams[i]->internal->avctx);
4142         av_freep(&ic->streams[i]->info);
4143         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4144         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4145     }
4146     if (ic->pb)
4147         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4148                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4149     return ret;
4150 }
4151
4152 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4153 {
4154     int i, j;
4155
4156     for (i = 0; i < ic->nb_programs; i++) {
4157         if (ic->programs[i] == last) {
4158             last = NULL;
4159         } else {
4160             if (!last)
4161                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4162                     if (ic->programs[i]->stream_index[j] == s)
4163                         return ic->programs[i];
4164         }
4165     }
4166     return NULL;
4167 }
4168
4169 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4170                         int wanted_stream_nb, int related_stream,
4171                         AVCodec **decoder_ret, int flags)
4172 {
4173     int i, nb_streams = ic->nb_streams;
4174     int ret = AVERROR_STREAM_NOT_FOUND;
4175     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4176     int count, multiframe, disposition;
4177     int64_t best_bitrate = -1;
4178     int64_t bitrate;
4179     unsigned *program = NULL;
4180     const AVCodec *decoder = NULL, *best_decoder = NULL;
4181
4182     if (related_stream >= 0 && wanted_stream_nb < 0) {
4183         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4184         if (p) {
4185             program    = p->stream_index;
4186             nb_streams = p->nb_stream_indexes;
4187         }
4188     }
4189     for (i = 0; i < nb_streams; i++) {
4190         int real_stream_index = program ? program[i] : i;
4191         AVStream *st          = ic->streams[real_stream_index];
4192         AVCodecParameters *par = st->codecpar;
4193         if (par->codec_type != type)
4194             continue;
4195         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4196             continue;
4197         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4198             continue;
4199         if (decoder_ret) {
4200             decoder = find_decoder(ic, st, par->codec_id);
4201             if (!decoder) {
4202                 if (ret < 0)
4203                     ret = AVERROR_DECODER_NOT_FOUND;
4204                 continue;
4205             }
4206         }
4207         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED));
4208         count = st->codec_info_nb_frames;
4209         bitrate = par->bit_rate;
4210         multiframe = FFMIN(5, count);
4211         if ((best_disposition >  disposition) ||
4212             (best_disposition == disposition && best_multiframe >  multiframe) ||
4213             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4214             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4215             continue;
4216         best_disposition = disposition;
4217         best_count   = count;
4218         best_bitrate = bitrate;
4219         best_multiframe = multiframe;
4220         ret          = real_stream_index;
4221         best_decoder = decoder;
4222         if (program && i == nb_streams - 1 && ret < 0) {
4223             program    = NULL;
4224             nb_streams = ic->nb_streams;
4225             /* no related stream found, try again with everything */
4226             i = 0;
4227         }
4228     }
4229     if (decoder_ret)
4230         *decoder_ret = (AVCodec*)best_decoder;
4231     return ret;
4232 }
4233
4234 /*******************************************************/
4235
4236 int av_read_play(AVFormatContext *s)
4237 {
4238     if (s->iformat->read_play)
4239         return s->iformat->read_play(s);
4240     if (s->pb)
4241         return avio_pause(s->pb, 0);
4242     return AVERROR(ENOSYS);
4243 }
4244
4245 int av_read_pause(AVFormatContext *s)
4246 {
4247     if (s->iformat->read_pause)
4248         return s->iformat->read_pause(s);
4249     if (s->pb)
4250         return avio_pause(s->pb, 1);
4251     return AVERROR(ENOSYS);
4252 }
4253
4254 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4255 {
4256     int ret, i;
4257
4258     dst->id                  = src->id;
4259     dst->time_base           = src->time_base;
4260     dst->nb_frames           = src->nb_frames;
4261     dst->disposition         = src->disposition;
4262     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4263     dst->avg_frame_rate      = src->avg_frame_rate;
4264     dst->r_frame_rate        = src->r_frame_rate;
4265
4266     av_dict_free(&dst->metadata);
4267     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4268     if (ret < 0)
4269         return ret;
4270
4271     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4272     if (ret < 0)
4273         return ret;
4274
4275     /* Free existing side data*/
4276     for (i = 0; i < dst->nb_side_data; i++)
4277         av_free(dst->side_data[i].data);
4278     av_freep(&dst->side_data);
4279     dst->nb_side_data = 0;
4280
4281     /* Copy side data if present */
4282     if (src->nb_side_data) {
4283         dst->side_data = av_mallocz_array(src->nb_side_data,
4284                                           sizeof(AVPacketSideData));
4285         if (!dst->side_data)
4286             return AVERROR(ENOMEM);
4287         dst->nb_side_data = src->nb_side_data;
4288
4289         for (i = 0; i < src->nb_side_data; i++) {
4290             uint8_t *data = av_memdup(src->side_data[i].data,
4291                                       src->side_data[i].size);
4292             if (!data)
4293                 return AVERROR(ENOMEM);
4294             dst->side_data[i].type = src->side_data[i].type;
4295             dst->side_data[i].size = src->side_data[i].size;
4296             dst->side_data[i].data = data;
4297         }
4298     }
4299
4300 #if FF_API_LAVF_FFSERVER
4301 FF_DISABLE_DEPRECATION_WARNINGS
4302     av_freep(&dst->recommended_encoder_configuration);
4303     if (src->recommended_encoder_configuration) {
4304         const char *conf_str = src->recommended_encoder_configuration;
4305         dst->recommended_encoder_configuration = av_strdup(conf_str);
4306         if (!dst->recommended_encoder_configuration)
4307             return AVERROR(ENOMEM);
4308     }
4309 FF_ENABLE_DEPRECATION_WARNINGS
4310 #endif
4311
4312     return 0;
4313 }
4314
4315 static void free_stream(AVStream **pst)
4316 {
4317     AVStream *st = *pst;
4318     int i;
4319
4320     if (!st)
4321         return;
4322
4323     for (i = 0; i < st->nb_side_data; i++)
4324         av_freep(&st->side_data[i].data);
4325     av_freep(&st->side_data);
4326
4327     if (st->parser)
4328         av_parser_close(st->parser);
4329
4330     if (st->attached_pic.data)
4331         av_packet_unref(&st->attached_pic);
4332
4333     if (st->internal) {
4334         avcodec_free_context(&st->internal->avctx);
4335         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4336             av_bsf_free(&st->internal->bsfcs[i]);
4337             av_freep(&st->internal->bsfcs);
4338         }
4339         av_freep(&st->internal->priv_pts);
4340         av_bsf_free(&st->internal->extract_extradata.bsf);
4341         av_packet_free(&st->internal->extract_extradata.pkt);
4342     }
4343     av_freep(&st->internal);
4344
4345     av_dict_free(&st->metadata);
4346     avcodec_parameters_free(&st->codecpar);
4347     av_freep(&st->probe_data.buf);
4348     av_freep(&st->index_entries);
4349 #if FF_API_LAVF_AVCTX
4350 FF_DISABLE_DEPRECATION_WARNINGS
4351     avcodec_free_context(&st->codec);
4352 FF_ENABLE_DEPRECATION_WARNINGS
4353 #endif
4354     av_freep(&st->priv_data);
4355     if (st->info)
4356         av_freep(&st->info->duration_error);
4357     av_freep(&st->info);
4358 #if FF_API_LAVF_FFSERVER
4359 FF_DISABLE_DEPRECATION_WARNINGS
4360     av_freep(&st->recommended_encoder_configuration);
4361 FF_ENABLE_DEPRECATION_WARNINGS
4362 #endif
4363
4364     av_freep(pst);
4365 }
4366
4367 void ff_free_stream(AVFormatContext *s, AVStream *st)
4368 {
4369     av_assert0(s->nb_streams>0);
4370     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4371
4372     free_stream(&s->streams[ --s->nb_streams ]);
4373 }
4374
4375 void avformat_free_context(AVFormatContext *s)
4376 {
4377     int i;
4378
4379     if (!s)
4380         return;
4381
4382     av_opt_free(s);
4383     if (s->iformat && s->iformat->priv_class && s->priv_data)
4384         av_opt_free(s->priv_data);
4385     if (s->oformat && s->oformat->priv_class && s->priv_data)
4386         av_opt_free(s->priv_data);
4387
4388     for (i = s->nb_streams - 1; i >= 0; i--)
4389         ff_free_stream(s, s->streams[i]);
4390
4391
4392     for (i = s->nb_programs - 1; i >= 0; i--) {
4393         av_dict_free(&s->programs[i]->metadata);
4394         av_freep(&s->programs[i]->stream_index);
4395         av_freep(&s->programs[i]);
4396     }
4397     av_freep(&s->programs);
4398     av_freep(&s->priv_data);
4399     while (s->nb_chapters--) {
4400         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4401         av_freep(&s->chapters[s->nb_chapters]);
4402     }
4403     av_freep(&s->chapters);
4404     av_dict_free(&s->metadata);
4405     av_dict_free(&s->internal->id3v2_meta);
4406     av_freep(&s->streams);
4407     flush_packet_queue(s);
4408     av_freep(&s->internal);
4409     av_freep(&s->url);
4410     av_free(s);
4411 }
4412
4413 void avformat_close_input(AVFormatContext **ps)
4414 {
4415     AVFormatContext *s;
4416     AVIOContext *pb;
4417
4418     if (!ps || !*ps)
4419         return;
4420
4421     s  = *ps;
4422     pb = s->pb;
4423
4424     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4425         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4426         pb = NULL;
4427
4428     flush_packet_queue(s);
4429
4430     if (s->iformat)
4431         if (s->iformat->read_close)
4432             s->iformat->read_close(s);
4433
4434     avformat_free_context(s);
4435
4436     *ps = NULL;
4437
4438     avio_close(pb);
4439 }
4440
4441 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4442 {
4443     AVStream *st;
4444     int i;
4445     AVStream **streams;
4446
4447     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4448         if (s->max_streams < INT_MAX/sizeof(*streams))
4449             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);
4450         return NULL;
4451     }
4452     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4453     if (!streams)
4454         return NULL;
4455     s->streams = streams;
4456
4457     st = av_mallocz(sizeof(AVStream));
4458     if (!st)
4459         return NULL;
4460     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4461         av_free(st);
4462         return NULL;
4463     }
4464     st->info->last_dts = AV_NOPTS_VALUE;
4465
4466 #if FF_API_LAVF_AVCTX
4467 FF_DISABLE_DEPRECATION_WARNINGS
4468     st->codec = avcodec_alloc_context3(c);
4469     if (!st->codec) {
4470         av_free(st->info);
4471         av_free(st);
4472         return NULL;
4473     }
4474 FF_ENABLE_DEPRECATION_WARNINGS
4475 #endif
4476
4477     st->internal = av_mallocz(sizeof(*st->internal));
4478     if (!st->internal)
4479         goto fail;
4480
4481     st->codecpar = avcodec_parameters_alloc();
4482     if (!st->codecpar)
4483         goto fail;
4484
4485     st->internal->avctx = avcodec_alloc_context3(NULL);
4486     if (!st->internal->avctx)
4487         goto fail;
4488
4489     if (s->iformat) {
4490 #if FF_API_LAVF_AVCTX
4491 FF_DISABLE_DEPRECATION_WARNINGS
4492         /* no default bitrate if decoding */
4493         st->codec->bit_rate = 0;
4494 FF_ENABLE_DEPRECATION_WARNINGS
4495 #endif
4496
4497         /* default pts setting is MPEG-like */
4498         avpriv_set_pts_info(st, 33, 1, 90000);
4499         /* we set the current DTS to 0 so that formats without any timestamps
4500          * but durations get some timestamps, formats with some unknown
4501          * timestamps have their first few packets buffered and the
4502          * timestamps corrected before they are returned to the user */
4503         st->cur_dts = RELATIVE_TS_BASE;
4504     } else {
4505         st->cur_dts = AV_NOPTS_VALUE;
4506     }
4507
4508     st->index      = s->nb_streams;
4509     st->start_time = AV_NOPTS_VALUE;
4510     st->duration   = AV_NOPTS_VALUE;
4511     st->first_dts     = AV_NOPTS_VALUE;
4512     st->probe_packets = MAX_PROBE_PACKETS;
4513     st->pts_wrap_reference = AV_NOPTS_VALUE;
4514     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4515
4516     st->last_IP_pts = AV_NOPTS_VALUE;
4517     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4518     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4519         st->pts_buffer[i] = AV_NOPTS_VALUE;
4520
4521     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4522
4523 #if FF_API_R_FRAME_RATE
4524     st->info->last_dts      = AV_NOPTS_VALUE;
4525 #endif
4526     st->info->fps_first_dts = AV_NOPTS_VALUE;
4527     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4528
4529     st->inject_global_side_data = s->internal->inject_global_side_data;
4530
4531     st->internal->need_context_update = 1;
4532
4533     s->streams[s->nb_streams++] = st;
4534     return st;
4535 fail:
4536     free_stream(&st);
4537     return NULL;
4538 }
4539
4540 AVProgram *av_new_program(AVFormatContext *ac, int id)
4541 {
4542     AVProgram *program = NULL;
4543     int i;
4544
4545     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4546
4547     for (i = 0; i < ac->nb_programs; i++)
4548         if (ac->programs[i]->id == id)
4549             program = ac->programs[i];
4550
4551     if (!program) {
4552         program = av_mallocz(sizeof(AVProgram));
4553         if (!program)
4554             return NULL;
4555         dynarray_add(&ac->programs, &ac->nb_programs, program);
4556         program->discard = AVDISCARD_NONE;
4557     }
4558     program->id = id;
4559     program->pts_wrap_reference = AV_NOPTS_VALUE;
4560     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4561
4562     program->start_time =
4563     program->end_time   = AV_NOPTS_VALUE;
4564
4565     return program;
4566 }
4567
4568 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4569                               int64_t start, int64_t end, const char *title)
4570 {
4571     AVChapter *chapter = NULL;
4572     int i;
4573
4574     if (end != AV_NOPTS_VALUE && start > end) {
4575         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4576         return NULL;
4577     }
4578
4579     for (i = 0; i < s->nb_chapters; i++)
4580         if (s->chapters[i]->id == id)
4581             chapter = s->chapters[i];
4582
4583     if (!chapter) {
4584         chapter = av_mallocz(sizeof(AVChapter));
4585         if (!chapter)
4586             return NULL;
4587         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4588     }
4589     av_dict_set(&chapter->metadata, "title", title, 0);
4590     chapter->id        = id;
4591     chapter->time_base = time_base;
4592     chapter->start     = start;
4593     chapter->end       = end;
4594
4595     return chapter;
4596 }
4597
4598 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4599 {
4600     int i, j;
4601     AVProgram *program = NULL;
4602     void *tmp;
4603
4604     if (idx >= ac->nb_streams) {
4605         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4606         return;
4607     }
4608
4609     for (i = 0; i < ac->nb_programs; i++) {
4610         if (ac->programs[i]->id != progid)
4611             continue;
4612         program = ac->programs[i];
4613         for (j = 0; j < program->nb_stream_indexes; j++)
4614             if (program->stream_index[j] == idx)
4615                 return;
4616
4617         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4618         if (!tmp)
4619             return;
4620         program->stream_index = tmp;
4621         program->stream_index[program->nb_stream_indexes++] = idx;
4622         return;
4623     }
4624 }
4625
4626 uint64_t ff_ntp_time(void)
4627 {
4628     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4629 }
4630
4631 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4632 {
4633     const char *p;
4634     char *q, buf1[20], c;
4635     int nd, len, percentd_found;
4636
4637     q = buf;
4638     p = path;
4639     percentd_found = 0;
4640     for (;;) {
4641         c = *p++;
4642         if (c == '\0')
4643             break;
4644         if (c == '%') {
4645             do {
4646                 nd = 0;
4647                 while (av_isdigit(*p))
4648                     nd = nd * 10 + *p++ - '0';
4649                 c = *p++;
4650             } while (av_isdigit(c));
4651
4652             switch (c) {
4653             case '%':
4654                 goto addchar;
4655             case 'd':
4656                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4657                     goto fail;
4658                 percentd_found = 1;
4659                 if (number < 0)
4660                     nd += 1;
4661                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4662                 len = strlen(buf1);
4663                 if ((q - buf + len) > buf_size - 1)
4664                     goto fail;
4665                 memcpy(q, buf1, len);
4666                 q += len;
4667                 break;
4668             default:
4669                 goto fail;
4670             }
4671         } else {
4672 addchar:
4673             if ((q - buf) < buf_size - 1)
4674                 *q++ = c;
4675         }
4676     }
4677     if (!percentd_found)
4678         goto fail;
4679     *q = '\0';
4680     return 0;
4681 fail:
4682     *q = '\0';
4683     return -1;
4684 }
4685
4686 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4687 {
4688     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4689 }
4690
4691 void av_url_split(char *proto, int proto_size,
4692                   char *authorization, int authorization_size,
4693                   char *hostname, int hostname_size,
4694                   int *port_ptr, char *path, int path_size, const char *url)
4695 {
4696     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4697
4698     if (port_ptr)
4699         *port_ptr = -1;
4700     if (proto_size > 0)
4701         proto[0] = 0;
4702     if (authorization_size > 0)
4703         authorization[0] = 0;
4704     if (hostname_size > 0)
4705         hostname[0] = 0;
4706     if (path_size > 0)
4707         path[0] = 0;
4708
4709     /* parse protocol */
4710     if ((p = strchr(url, ':'))) {
4711         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4712         p++; /* skip ':' */
4713         if (*p == '/')
4714             p++;
4715         if (*p == '/')
4716             p++;
4717     } else {
4718         /* no protocol means plain filename */
4719         av_strlcpy(path, url, path_size);
4720         return;
4721     }
4722
4723     /* separate path from hostname */
4724     ls = strchr(p, '/');
4725     ls2 = strchr(p, '?');
4726     if (!ls)
4727         ls = ls2;
4728     else if (ls && ls2)
4729         ls = FFMIN(ls, ls2);
4730     if (ls)
4731         av_strlcpy(path, ls, path_size);
4732     else
4733         ls = &p[strlen(p)];  // XXX
4734
4735     /* the rest is hostname, use that to parse auth/port */
4736     if (ls != p) {
4737         /* authorization (user[:pass]@hostname) */
4738         at2 = p;
4739         while ((at = strchr(p, '@')) && at < ls) {
4740             av_strlcpy(authorization, at2,
4741                        FFMIN(authorization_size, at + 1 - at2));
4742             p = at + 1; /* skip '@' */
4743         }
4744
4745         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4746             /* [host]:port */
4747             av_strlcpy(hostname, p + 1,
4748                        FFMIN(hostname_size, brk - p));
4749             if (brk[1] == ':' && port_ptr)
4750                 *port_ptr = atoi(brk + 2);
4751         } else if ((col = strchr(p, ':')) && col < ls) {
4752             av_strlcpy(hostname, p,
4753                        FFMIN(col + 1 - p, hostname_size));
4754             if (port_ptr)
4755                 *port_ptr = atoi(col + 1);
4756         } else
4757             av_strlcpy(hostname, p,
4758                        FFMIN(ls + 1 - p, hostname_size));
4759     }
4760 }
4761
4762 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4763 {
4764     int i;
4765     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4766                                            '4', '5', '6', '7',
4767                                            '8', '9', 'A', 'B',
4768                                            'C', 'D', 'E', 'F' };
4769     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4770                                            '4', '5', '6', '7',
4771                                            '8', '9', 'a', 'b',
4772                                            'c', 'd', 'e', 'f' };
4773     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4774
4775     for (i = 0; i < s; i++) {
4776         buff[i * 2]     = hex_table[src[i] >> 4];
4777         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4778     }
4779
4780     return buff;
4781 }
4782
4783 int ff_hex_to_data(uint8_t *data, const char *p)
4784 {
4785     int c, len, v;
4786
4787     len = 0;
4788     v   = 1;
4789     for (;;) {
4790         p += strspn(p, SPACE_CHARS);
4791         if (*p == '\0')
4792             break;
4793         c = av_toupper((unsigned char) *p++);
4794         if (c >= '0' && c <= '9')
4795             c = c - '0';
4796         else if (c >= 'A' && c <= 'F')
4797             c = c - 'A' + 10;
4798         else
4799             break;
4800         v = (v << 4) | c;
4801         if (v & 0x100) {
4802             if (data)
4803                 data[len] = v;
4804             len++;
4805             v = 1;
4806         }
4807     }
4808     return len;
4809 }
4810
4811 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4812                          unsigned int pts_num, unsigned int pts_den)
4813 {
4814     AVRational new_tb;
4815     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4816         if (new_tb.num != pts_num)
4817             av_log(NULL, AV_LOG_DEBUG,
4818                    "st:%d removing common factor %d from timebase\n",
4819                    s->index, pts_num / new_tb.num);
4820     } else
4821         av_log(NULL, AV_LOG_WARNING,
4822                "st:%d has too large timebase, reducing\n", s->index);
4823
4824     if (new_tb.num <= 0 || new_tb.den <= 0) {
4825         av_log(NULL, AV_LOG_ERROR,
4826                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4827                new_tb.num, new_tb.den,
4828                s->index);
4829         return;
4830     }
4831     s->time_base     = new_tb;
4832 #if FF_API_LAVF_AVCTX
4833 FF_DISABLE_DEPRECATION_WARNINGS
4834     s->codec->pkt_timebase = new_tb;
4835 FF_ENABLE_DEPRECATION_WARNINGS
4836 #endif
4837     s->internal->avctx->pkt_timebase = new_tb;
4838     s->pts_wrap_bits = pts_wrap_bits;
4839 }
4840
4841 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4842                         void *context)
4843 {
4844     const char *ptr = str;
4845
4846     /* Parse key=value pairs. */
4847     for (;;) {
4848         const char *key;
4849         char *dest = NULL, *dest_end;
4850         int key_len, dest_len = 0;
4851
4852         /* Skip whitespace and potential commas. */
4853         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4854             ptr++;
4855         if (!*ptr)
4856             break;
4857
4858         key = ptr;
4859
4860         if (!(ptr = strchr(key, '=')))
4861             break;
4862         ptr++;
4863         key_len = ptr - key;
4864
4865         callback_get_buf(context, key, key_len, &dest, &dest_len);
4866         dest_end = dest + dest_len - 1;
4867
4868         if (*ptr == '\"') {
4869             ptr++;
4870             while (*ptr && *ptr != '\"') {
4871                 if (*ptr == '\\') {
4872                     if (!ptr[1])
4873                         break;
4874                     if (dest && dest < dest_end)
4875                         *dest++ = ptr[1];
4876                     ptr += 2;
4877                 } else {
4878                     if (dest && dest < dest_end)
4879                         *dest++ = *ptr;
4880                     ptr++;
4881                 }
4882             }
4883             if (*ptr == '\"')
4884                 ptr++;
4885         } else {
4886             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4887                 if (dest && dest < dest_end)
4888                     *dest++ = *ptr;
4889         }
4890         if (dest)
4891             *dest = 0;
4892     }
4893 }
4894
4895 int ff_find_stream_index(AVFormatContext *s, int id)
4896 {
4897     int i;
4898     for (i = 0; i < s->nb_streams; i++)
4899         if (s->streams[i]->id == id)
4900             return i;
4901     return -1;
4902 }
4903
4904 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4905                          int std_compliance)
4906 {
4907     if (ofmt) {
4908         unsigned int codec_tag;
4909         if (ofmt->query_codec)
4910             return ofmt->query_codec(codec_id, std_compliance);
4911         else if (ofmt->codec_tag)
4912             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4913         else if (codec_id == ofmt->video_codec ||
4914                  codec_id == ofmt->audio_codec ||
4915                  codec_id == ofmt->subtitle_codec ||
4916                  codec_id == ofmt->data_codec)
4917             return 1;
4918     }
4919     return AVERROR_PATCHWELCOME;
4920 }
4921
4922 int avformat_network_init(void)
4923 {
4924 #if CONFIG_NETWORK
4925     int ret;
4926     if ((ret = ff_network_init()) < 0)
4927         return ret;
4928     if ((ret = ff_tls_init()) < 0)
4929         return ret;
4930 #endif
4931     return 0;
4932 }
4933
4934 int avformat_network_deinit(void)
4935 {
4936 #if CONFIG_NETWORK
4937     ff_network_close();
4938     ff_tls_deinit();
4939 #endif
4940     return 0;
4941 }
4942
4943 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4944                         uint64_t channel_layout, int32_t sample_rate,
4945                         int32_t width, int32_t height)
4946 {
4947     uint32_t flags = 0;
4948     int size = 4;
4949     uint8_t *data;
4950     if (!pkt)
4951         return AVERROR(EINVAL);
4952     if (channels) {
4953         size  += 4;
4954         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4955     }
4956     if (channel_layout) {
4957         size  += 8;
4958         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4959     }
4960     if (sample_rate) {
4961         size  += 4;
4962         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4963     }
4964     if (width || height) {
4965         size  += 8;
4966         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4967     }
4968     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4969     if (!data)
4970         return AVERROR(ENOMEM);
4971     bytestream_put_le32(&data, flags);
4972     if (channels)
4973         bytestream_put_le32(&data, channels);
4974     if (channel_layout)
4975         bytestream_put_le64(&data, channel_layout);
4976     if (sample_rate)
4977         bytestream_put_le32(&data, sample_rate);
4978     if (width || height) {
4979         bytestream_put_le32(&data, width);
4980         bytestream_put_le32(&data, height);
4981     }
4982     return 0;
4983 }
4984
4985 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4986 {
4987     AVRational undef = {0, 1};
4988     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4989     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
4990     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4991
4992     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4993                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4994     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4995         stream_sample_aspect_ratio = undef;
4996
4997     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4998                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4999     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5000         frame_sample_aspect_ratio = undef;
5001
5002     if (stream_sample_aspect_ratio.num)
5003         return stream_sample_aspect_ratio;
5004     else
5005         return frame_sample_aspect_ratio;
5006 }
5007
5008 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5009 {
5010     AVRational fr = st->r_frame_rate;
5011     AVRational codec_fr = st->internal->avctx->framerate;
5012     AVRational   avg_fr = st->avg_frame_rate;
5013
5014     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5015         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5016         fr = avg_fr;
5017     }
5018
5019
5020     if (st->internal->avctx->ticks_per_frame > 1) {
5021         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5022             (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))
5023             fr = codec_fr;
5024     }
5025
5026     return fr;
5027 }
5028
5029 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5030                                     const char *spec)
5031 {
5032     if (*spec <= '9' && *spec >= '0') /* opt:index */
5033         return strtol(spec, NULL, 0) == st->index;
5034     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5035              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5036         enum AVMediaType type;
5037         int nopic = 0;
5038
5039         switch (*spec++) {
5040         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5041         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5042         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5043         case 'd': type = AVMEDIA_TYPE_DATA;       break;
5044         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5045         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5046         default:  av_assert0(0);
5047         }
5048 #if FF_API_LAVF_AVCTX
5049 FF_DISABLE_DEPRECATION_WARNINGS
5050         if (type != st->codecpar->codec_type
5051            && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5052             return 0;
5053 FF_ENABLE_DEPRECATION_WARNINGS
5054 #else
5055         if (type != st->codecpar->codec_type)
5056             return 0;
5057 #endif
5058         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5059             return 0;
5060         if (*spec++ == ':') { /* possibly followed by :index */
5061             int i, index = strtol(spec, NULL, 0);
5062             for (i = 0; i < s->nb_streams; i++) {
5063 #if FF_API_LAVF_AVCTX
5064 FF_DISABLE_DEPRECATION_WARNINGS
5065                 if ((s->streams[i]->codecpar->codec_type == type
5066                       || s->streams[i]->codec->codec_type == type
5067                     ) &&
5068                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5069                     index-- == 0)
5070                     return i == st->index;
5071 FF_ENABLE_DEPRECATION_WARNINGS
5072 #else
5073                 if ((s->streams[i]->codecpar->codec_type == type) &&
5074                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
5075                     index-- == 0)
5076                     return i == st->index;
5077 #endif
5078             }
5079             return 0;
5080         }
5081         return 1;
5082     } else if (*spec == 'p' && *(spec + 1) == ':') {
5083         int prog_id, i, j;
5084         char *endptr;
5085         spec += 2;
5086         prog_id = strtol(spec, &endptr, 0);
5087         for (i = 0; i < s->nb_programs; i++) {
5088             if (s->programs[i]->id != prog_id)
5089                 continue;
5090
5091             if (*endptr++ == ':') {  // p:<id>:....
5092                 if ( *endptr == 'a' || *endptr == 'v' ||
5093                      *endptr == 's' || *endptr == 'd') {  // p:<id>:<st_type>[:<index>]
5094                     enum AVMediaType type;
5095
5096                     switch (*endptr++) {
5097                     case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5098                     case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5099                     case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5100                     case 'd': type = AVMEDIA_TYPE_DATA;       break;
5101                     default:  av_assert0(0);
5102                     }
5103                     if (*endptr++ == ':') {  // p:<id>:<st_type>:<index>
5104                         int stream_idx = strtol(endptr, NULL, 0), type_counter = 0;
5105                         for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5106                             int stream_index = s->programs[i]->stream_index[j];
5107                             if (st->index == s->programs[i]->stream_index[j]) {
5108 #if FF_API_LAVF_AVCTX
5109 FF_DISABLE_DEPRECATION_WARNINGS
5110                                 return type_counter == stream_idx &&
5111                                        (type == st->codecpar->codec_type ||
5112                                         type == st->codec->codec_type);
5113 FF_ENABLE_DEPRECATION_WARNINGS
5114 #else
5115                                 return type_counter == stream_idx &&
5116                                        type == st->codecpar->codec_type;
5117 #endif
5118                              }
5119 #if FF_API_LAVF_AVCTX
5120 FF_DISABLE_DEPRECATION_WARNINGS
5121                             if (type == s->streams[stream_index]->codecpar->codec_type ||
5122                                 type == s->streams[stream_index]->codec->codec_type)
5123                                 type_counter++;
5124 FF_ENABLE_DEPRECATION_WARNINGS
5125 #else
5126                             if (type == s->streams[stream_index]->codecpar->codec_type)
5127                                 type_counter++;
5128 #endif
5129                         }
5130                         return 0;
5131                     } else {  // p:<id>:<st_type>
5132                         for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5133                             if (st->index == s->programs[i]->stream_index[j]) {
5134 #if FF_API_LAVF_AVCTX
5135 FF_DISABLE_DEPRECATION_WARNINGS
5136                                  return type == st->codecpar->codec_type ||
5137                                         type == st->codec->codec_type;
5138 FF_ENABLE_DEPRECATION_WARNINGS
5139 #else
5140                                  return type == st->codecpar->codec_type;
5141 #endif
5142                             }
5143                         return 0;
5144                     }
5145
5146                 } else if ( *endptr == 'm') { // p:<id>:m:<metadata_spec>
5147                     AVDictionaryEntry *tag;
5148                     char *key, *val;
5149                     int ret = 0;
5150
5151                     if (*(++endptr) != ':') {
5152                         av_log(s, AV_LOG_ERROR, "Invalid stream specifier syntax, missing ':' sign after :m.\n");
5153                         return AVERROR(EINVAL);
5154                     }
5155
5156                     val = strchr(++endptr, ':');
5157                     key = val ? av_strndup(endptr, val - endptr) : av_strdup(endptr);
5158                     if (!key)
5159                         return AVERROR(ENOMEM);
5160
5161                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5162                         if (st->index == s->programs[i]->stream_index[j]) {
5163                             tag = av_dict_get(st->metadata, key, NULL, 0);
5164                             if (tag && (!val || !strcmp(tag->value, val + 1)))
5165                                 ret = 1;
5166
5167                             break;
5168                         }
5169
5170                     av_freep(&key);
5171                     return ret;
5172
5173                 } else {  // p:<id>:<index>
5174                     int stream_idx = strtol(endptr, NULL, 0);
5175                     return stream_idx >= 0 &&
5176                            stream_idx < s->programs[i]->nb_stream_indexes &&
5177                            st->index == s->programs[i]->stream_index[stream_idx];
5178                 }
5179             }
5180
5181             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
5182                 if (st->index == s->programs[i]->stream_index[j])
5183                     return 1;
5184         }
5185         return 0;
5186     } else if (*spec == '#' ||
5187                (*spec == 'i' && *(spec + 1) == ':')) {
5188         int stream_id;
5189         char *endptr;
5190         spec += 1 + (*spec == 'i');
5191         stream_id = strtol(spec, &endptr, 0);
5192         if (!*endptr)
5193             return stream_id == st->id;
5194     } else if (*spec == 'm' && *(spec + 1) == ':') {
5195         AVDictionaryEntry *tag;
5196         char *key, *val;
5197         int ret;
5198
5199         spec += 2;
5200         val = strchr(spec, ':');
5201
5202         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5203         if (!key)
5204             return AVERROR(ENOMEM);
5205
5206         tag = av_dict_get(st->metadata, key, NULL, 0);
5207         if (tag) {
5208             if (!val || !strcmp(tag->value, val + 1))
5209                 ret = 1;
5210             else
5211                 ret = 0;
5212         } else
5213             ret = 0;
5214
5215         av_freep(&key);
5216         return ret;
5217     } else if (*spec == 'u') {
5218         AVCodecParameters *par = st->codecpar;
5219 #if FF_API_LAVF_AVCTX
5220 FF_DISABLE_DEPRECATION_WARNINGS
5221         AVCodecContext *codec = st->codec;
5222 FF_ENABLE_DEPRECATION_WARNINGS
5223 #endif
5224         int val;
5225         switch (par->codec_type) {
5226         case AVMEDIA_TYPE_AUDIO:
5227             val = par->sample_rate && par->channels;
5228 #if FF_API_LAVF_AVCTX
5229             val = val || (codec->sample_rate && codec->channels);
5230 #endif
5231             if (par->format == AV_SAMPLE_FMT_NONE
5232 #if FF_API_LAVF_AVCTX
5233                 && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5234 #endif
5235                 )
5236                 return 0;
5237             break;
5238         case AVMEDIA_TYPE_VIDEO:
5239             val = par->width && par->height;
5240 #if FF_API_LAVF_AVCTX
5241             val = val || (codec->width && codec->height);
5242 #endif
5243             if (par->format == AV_PIX_FMT_NONE
5244 #if FF_API_LAVF_AVCTX
5245                 && codec->pix_fmt == AV_PIX_FMT_NONE
5246 #endif
5247                 )
5248                 return 0;
5249             break;
5250         case AVMEDIA_TYPE_UNKNOWN:
5251             val = 0;
5252             break;
5253         default:
5254             val = 1;
5255             break;
5256         }
5257 #if FF_API_LAVF_AVCTX
5258         return (par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0;
5259 #else
5260         return par->codec_id != AV_CODEC_ID_NONE && val != 0;
5261 #endif
5262     } else if (!*spec) /* empty specifier, matches everything */
5263         return 1;
5264
5265     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5266     return AVERROR(EINVAL);
5267 }
5268
5269 int ff_generate_avci_extradata(AVStream *st)
5270 {
5271     static const uint8_t avci100_1080p_extradata[] = {
5272         // SPS
5273         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5274         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5275         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5276         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5277         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5278         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5279         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5280         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5281         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5282         // PPS
5283         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5284         0xd0
5285     };
5286     static const uint8_t avci100_1080i_extradata[] = {
5287         // SPS
5288         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5289         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5290         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5291         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5292         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5293         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5294         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5295         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5296         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5297         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5298         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5299         // PPS
5300         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5301         0xd0
5302     };
5303     static const uint8_t avci50_1080p_extradata[] = {
5304         // SPS
5305         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5306         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5307         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5308         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5309         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5310         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5311         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5312         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5313         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5314         // PPS
5315         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5316         0x11
5317     };
5318     static const uint8_t avci50_1080i_extradata[] = {
5319         // SPS
5320         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5321         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5322         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5323         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5324         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5325         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5326         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5327         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5328         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5329         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5330         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5331         // PPS
5332         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5333         0x11
5334     };
5335     static const uint8_t avci100_720p_extradata[] = {
5336         // SPS
5337         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5338         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5339         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5340         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5341         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5342         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5343         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5344         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5345         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5346         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5347         // PPS
5348         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5349         0x11
5350     };
5351     static const uint8_t avci50_720p_extradata[] = {
5352         // SPS
5353         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5354         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5355         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5356         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5357         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5358         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5359         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5360         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5361         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5362         // PPS
5363         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5364         0x11
5365     };
5366
5367     const uint8_t *data = NULL;
5368     int size            = 0;
5369
5370     if (st->codecpar->width == 1920) {
5371         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5372             data = avci100_1080p_extradata;
5373             size = sizeof(avci100_1080p_extradata);
5374         } else {
5375             data = avci100_1080i_extradata;
5376             size = sizeof(avci100_1080i_extradata);
5377         }
5378     } else if (st->codecpar->width == 1440) {
5379         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5380             data = avci50_1080p_extradata;
5381             size = sizeof(avci50_1080p_extradata);
5382         } else {
5383             data = avci50_1080i_extradata;
5384             size = sizeof(avci50_1080i_extradata);
5385         }
5386     } else if (st->codecpar->width == 1280) {
5387         data = avci100_720p_extradata;
5388         size = sizeof(avci100_720p_extradata);
5389     } else if (st->codecpar->width == 960) {
5390         data = avci50_720p_extradata;
5391         size = sizeof(avci50_720p_extradata);
5392     }
5393
5394     if (!size)
5395         return 0;
5396
5397     av_freep(&st->codecpar->extradata);
5398     if (ff_alloc_extradata(st->codecpar, size))
5399         return AVERROR(ENOMEM);
5400     memcpy(st->codecpar->extradata, data, size);
5401
5402     return 0;
5403 }
5404
5405 uint8_t *av_stream_get_side_data(const AVStream *st,
5406                                  enum AVPacketSideDataType type, int *size)
5407 {
5408     int i;
5409
5410     for (i = 0; i < st->nb_side_data; i++) {
5411         if (st->side_data[i].type == type) {
5412             if (size)
5413                 *size = st->side_data[i].size;
5414             return st->side_data[i].data;
5415         }
5416     }
5417     return NULL;
5418 }
5419
5420 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5421                             uint8_t *data, size_t size)
5422 {
5423     AVPacketSideData *sd, *tmp;
5424     int i;
5425
5426     for (i = 0; i < st->nb_side_data; i++) {
5427         sd = &st->side_data[i];
5428
5429         if (sd->type == type) {
5430             av_freep(&sd->data);
5431             sd->data = data;
5432             sd->size = size;
5433             return 0;
5434         }
5435     }
5436
5437     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5438         return AVERROR(ERANGE);
5439
5440     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5441     if (!tmp) {
5442         return AVERROR(ENOMEM);
5443     }
5444
5445     st->side_data = tmp;
5446     st->nb_side_data++;
5447
5448     sd = &st->side_data[st->nb_side_data - 1];
5449     sd->type = type;
5450     sd->data = data;
5451     sd->size = size;
5452
5453     return 0;
5454 }
5455
5456 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5457                                  int size)
5458 {
5459     int ret;
5460     uint8_t *data = av_malloc(size);
5461
5462     if (!data)
5463         return NULL;
5464
5465     ret = av_stream_add_side_data(st, type, data, size);
5466     if (ret < 0) {
5467         av_freep(&data);
5468         return NULL;
5469     }
5470
5471     return data;
5472 }
5473
5474 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5475 {
5476     int ret;
5477     const AVBitStreamFilter *bsf;
5478     AVBSFContext *bsfc;
5479     AVCodecParameters *in_par;
5480
5481     if (!(bsf = av_bsf_get_by_name(name))) {
5482         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5483         return AVERROR_BSF_NOT_FOUND;
5484     }
5485
5486     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5487         return ret;
5488
5489     if (st->internal->nb_bsfcs) {
5490         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5491         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5492     } else {
5493         in_par = st->codecpar;
5494         bsfc->time_base_in = st->time_base;
5495     }
5496
5497     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5498         av_bsf_free(&bsfc);
5499         return ret;
5500     }
5501
5502     if (args && bsfc->filter->priv_class) {
5503         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5504         const char * shorthand[2] = {NULL};
5505
5506         if (opt)
5507             shorthand[0] = opt->name;
5508
5509         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5510             av_bsf_free(&bsfc);
5511             return ret;
5512         }
5513     }
5514
5515     if ((ret = av_bsf_init(bsfc)) < 0) {
5516         av_bsf_free(&bsfc);
5517         return ret;
5518     }
5519
5520     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5521         av_bsf_free(&bsfc);
5522         return ret;
5523     }
5524
5525     av_log(NULL, AV_LOG_VERBOSE,
5526            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5527            name, args ? args : "");
5528     return 1;
5529 }
5530
5531 #if FF_API_OLD_BSF
5532 FF_DISABLE_DEPRECATION_WARNINGS
5533 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5534                                AVBitStreamFilterContext *bsfc)
5535 {
5536     int ret = 0;
5537     while (bsfc) {
5538         AVPacket new_pkt = *pkt;
5539         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5540                                            &new_pkt.data, &new_pkt.size,
5541                                            pkt->data, pkt->size,
5542                                            pkt->flags & AV_PKT_FLAG_KEY);
5543         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5544             av_packet_unref(pkt);
5545             memset(pkt, 0, sizeof(*pkt));
5546             return 0;
5547         }
5548         if(a == 0 && new_pkt.data != pkt->data) {
5549             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
5550             if (t) {
5551                 memcpy(t, new_pkt.data, new_pkt.size);
5552                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5553                 new_pkt.data = t;
5554                 new_pkt.buf = NULL;
5555                 a = 1;
5556             } else {
5557                 a = AVERROR(ENOMEM);
5558             }
5559         }
5560         if (a > 0) {
5561             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5562                                            av_buffer_default_free, NULL, 0);
5563             if (new_pkt.buf) {
5564                 pkt->side_data = NULL;
5565                 pkt->side_data_elems = 0;
5566                 av_packet_unref(pkt);
5567             } else {
5568                 av_freep(&new_pkt.data);
5569                 a = AVERROR(ENOMEM);
5570             }
5571         }
5572         if (a < 0) {
5573             av_log(codec, AV_LOG_ERROR,
5574                    "Failed to open bitstream filter %s for stream %d with codec %s",
5575                    bsfc->filter->name, pkt->stream_index,
5576                    codec->codec ? codec->codec->name : "copy");
5577             ret = a;
5578             break;
5579         }
5580         *pkt = new_pkt;
5581
5582         bsfc = bsfc->next;
5583     }
5584     return ret;
5585 }
5586 FF_ENABLE_DEPRECATION_WARNINGS
5587 #endif
5588
5589 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5590 {
5591     if (!s->oformat)
5592         return AVERROR(EINVAL);
5593
5594     if (!(s->oformat->flags & AVFMT_NOFILE))
5595         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5596     return 0;
5597 }
5598
5599 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5600 {
5601     if (*pb)
5602         s->io_close(s, *pb);
5603     *pb = NULL;
5604 }
5605
5606 int ff_is_http_proto(char *filename) {
5607     const char *proto = avio_find_protocol_name(filename);
5608     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5609 }
5610
5611 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5612 {
5613     AVDictionaryEntry *entry;
5614     int64_t parsed_timestamp;
5615     int ret;
5616     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5617         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5618             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5619             return 1;
5620         } else {
5621             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5622             return ret;
5623         }
5624     }
5625     return 0;
5626 }
5627
5628 int ff_standardize_creation_time(AVFormatContext *s)
5629 {
5630     int64_t timestamp;
5631     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5632     if (ret == 1)
5633         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5634     return ret;
5635 }
5636
5637 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5638 {
5639     uint8_t *side_data;
5640     int size;
5641
5642     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5643     if (side_data) {
5644         if (size != AVPALETTE_SIZE) {
5645             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5646             return AVERROR_INVALIDDATA;
5647         }
5648         memcpy(palette, side_data, AVPALETTE_SIZE);
5649         return 1;
5650     }
5651
5652     if (ret == CONTAINS_PAL) {
5653         int i;
5654         for (i = 0; i < AVPALETTE_COUNT; i++)
5655             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5656         return 1;
5657     }
5658
5659     return 0;
5660 }
5661
5662 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5663 {
5664     int ret;
5665     char *str;
5666
5667     ret = av_bprint_finalize(buf, &str);
5668     if (ret < 0)
5669         return ret;
5670     if (!av_bprint_is_complete(buf)) {
5671         av_free(str);
5672         return AVERROR(ENOMEM);
5673     }
5674
5675     par->extradata = str;
5676     /* Note: the string is NUL terminated (so extradata can be read as a
5677      * string), but the ending character is not accounted in the size (in
5678      * binary formats you are likely not supposed to mux that character). When
5679      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5680      * zeros. */
5681     par->extradata_size = buf->len;
5682     return 0;
5683 }
5684
5685 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5686                                                   AVStream *ost, const AVStream *ist,
5687                                                   enum AVTimebaseSource copy_tb)
5688 {
5689     //TODO: use [io]st->internal->avctx
5690     const AVCodecContext *dec_ctx = ist->codec;
5691     AVCodecContext       *enc_ctx = ost->codec;
5692
5693     enc_ctx->time_base = ist->time_base;
5694     /*
5695      * Avi is a special case here because it supports variable fps but
5696      * having the fps and timebase differe significantly adds quite some
5697      * overhead
5698      */
5699     if (!strcmp(ofmt->name, "avi")) {
5700 #if FF_API_R_FRAME_RATE
5701         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5702             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5703             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5704             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5705             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5706             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5707             enc_ctx->time_base.num = ist->r_frame_rate.den;
5708             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5709             enc_ctx->ticks_per_frame = 2;
5710         } else
5711 #endif
5712             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5713                    && av_q2d(ist->time_base) < 1.0/500
5714                    || copy_tb == AVFMT_TBCF_DECODER) {
5715             enc_ctx->time_base = dec_ctx->time_base;
5716             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5717             enc_ctx->time_base.den *= 2;
5718             enc_ctx->ticks_per_frame = 2;
5719         }
5720     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5721                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5722         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5723             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5724             && av_q2d(ist->time_base) < 1.0/500
5725             || copy_tb == AVFMT_TBCF_DECODER) {
5726             enc_ctx->time_base = dec_ctx->time_base;
5727             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5728         }
5729     }
5730
5731     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5732         && dec_ctx->time_base.num < dec_ctx->time_base.den
5733         && dec_ctx->time_base.num > 0
5734         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5735         enc_ctx->time_base = dec_ctx->time_base;
5736     }
5737
5738     if (ost->avg_frame_rate.num)
5739         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5740
5741     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5742               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5743
5744     return 0;
5745 }
5746
5747 AVRational av_stream_get_codec_timebase(const AVStream *st)
5748 {
5749     // See avformat_transfer_internal_stream_timing_info() TODO.
5750 #if FF_API_LAVF_AVCTX
5751 FF_DISABLE_DEPRECATION_WARNINGS
5752     return st->codec->time_base;
5753 FF_ENABLE_DEPRECATION_WARNINGS
5754 #else
5755     return st->internal->avctx->time_base;
5756 #endif
5757 }
5758
5759 void ff_format_set_url(AVFormatContext *s, char *url)
5760 {
5761     av_assert0(url);
5762     av_freep(&s->url);
5763     s->url = url;
5764 #if FF_API_FORMAT_FILENAME
5765 FF_DISABLE_DEPRECATION_WARNINGS
5766     av_strlcpy(s->filename, url, sizeof(s->filename));
5767 FF_ENABLE_DEPRECATION_WARNINGS
5768 #endif
5769 }