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

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