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