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