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