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