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