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