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