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

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