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         int extradata_size;
3571         uint8_t *extradata;
3572
3573         ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
3574         if (ret < 0) {
3575             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
3576                 return ret;
3577             continue;
3578         }
3579
3580         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
3581                                             &extradata_size);
3582
3583         if (extradata) {
3584             av_assert0(!sti->avctx->extradata);
3585             if ((unsigned)extradata_size < FF_MAX_EXTRADATA_SIZE)
3586                 sti->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
3587             if (!sti->avctx->extradata) {
3588                 av_packet_unref(pkt_ref);
3589                 return AVERROR(ENOMEM);
3590             }
3591             memcpy(sti->avctx->extradata, extradata, extradata_size);
3592             sti->avctx->extradata_size = extradata_size;
3593         }
3594         av_packet_unref(pkt_ref);
3595     }
3596
3597     return 0;
3598 }
3599
3600 static int add_coded_side_data(AVStream *st, AVCodecContext *avctx)
3601 {
3602     int i;
3603
3604     for (i = 0; i < avctx->nb_coded_side_data; i++) {
3605         const AVPacketSideData *sd_src = &avctx->coded_side_data[i];
3606         uint8_t *dst_data;
3607         dst_data = av_stream_new_side_data(st, sd_src->type, sd_src->size);
3608         if (!dst_data)
3609             return AVERROR(ENOMEM);
3610         memcpy(dst_data, sd_src->data, sd_src->size);
3611     }
3612     return 0;
3613 }
3614
3615 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3616 {
3617     int i, count = 0, ret = 0, j;
3618     int64_t read_size;
3619     AVStream *st;
3620     AVCodecContext *avctx;
3621     AVPacket pkt1;
3622     int64_t old_offset  = avio_tell(ic->pb);
3623     // new streams might appear, no options for those
3624     int orig_nb_streams = ic->nb_streams;
3625     int flush_codecs;
3626     int64_t max_analyze_duration = ic->max_analyze_duration;
3627     int64_t max_stream_analyze_duration;
3628     int64_t max_subtitle_analyze_duration;
3629     int64_t probesize = ic->probesize;
3630     int eof_reached = 0;
3631     int *missing_streams = av_opt_ptr(ic->iformat->priv_class, ic->priv_data, "missing_streams");
3632
3633     flush_codecs = probesize > 0;
3634
3635     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3636
3637     max_stream_analyze_duration = max_analyze_duration;
3638     max_subtitle_analyze_duration = max_analyze_duration;
3639     if (!max_analyze_duration) {
3640         max_stream_analyze_duration =
3641         max_analyze_duration        = 5*AV_TIME_BASE;
3642         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3643         if (!strcmp(ic->iformat->name, "flv"))
3644             max_stream_analyze_duration = 90*AV_TIME_BASE;
3645         if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
3646             max_stream_analyze_duration = 7*AV_TIME_BASE;
3647     }
3648
3649     if (ic->pb)
3650         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
3651                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, ic->nb_streams);
3652
3653     for (i = 0; i < ic->nb_streams; i++) {
3654         const AVCodec *codec;
3655         AVDictionary *thread_opt = NULL;
3656         st = ic->streams[i];
3657         avctx = st->internal->avctx;
3658
3659         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3660             st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3661 /*            if (!st->time_base.num)
3662                 st->time_base = */
3663             if (!avctx->time_base.num)
3664                 avctx->time_base = st->time_base;
3665         }
3666
3667         /* check if the caller has overridden the codec id */
3668 #if FF_API_LAVF_AVCTX
3669 FF_DISABLE_DEPRECATION_WARNINGS
3670         if (st->codec->codec_id != st->internal->orig_codec_id) {
3671             st->codecpar->codec_id   = st->codec->codec_id;
3672             st->codecpar->codec_type = st->codec->codec_type;
3673             st->internal->orig_codec_id = st->codec->codec_id;
3674         }
3675 FF_ENABLE_DEPRECATION_WARNINGS
3676 #endif
3677         // only for the split stuff
3678         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3679             st->parser = av_parser_init(st->codecpar->codec_id);
3680             if (st->parser) {
3681                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3682                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3683                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3684                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3685                 }
3686             } else if (st->need_parsing) {
3687                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3688                        "%s, packets or times may be invalid.\n",
3689                        avcodec_get_name(st->codecpar->codec_id));
3690             }
3691         }
3692
3693         if (st->codecpar->codec_id != st->internal->orig_codec_id)
3694             st->internal->orig_codec_id = st->codecpar->codec_id;
3695
3696         ret = avcodec_parameters_to_context(avctx, st->codecpar);
3697         if (ret < 0)
3698             goto find_stream_info_err;
3699         if (st->request_probe <= 0)
3700             st->internal->avctx_inited = 1;
3701
3702         codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3703
3704         /* Force thread count to 1 since the H.264 decoder will not extract
3705          * SPS and PPS to extradata during multi-threaded decoding. */
3706         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3707
3708         if (ic->codec_whitelist)
3709             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3710
3711         /* Ensure that subtitle_header is properly set. */
3712         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
3713             && codec && !avctx->codec) {
3714             if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3715                 av_log(ic, AV_LOG_WARNING,
3716                        "Failed to open codec in %s\n",__FUNCTION__);
3717         }
3718
3719         // Try to just open decoders, in case this is enough to get parameters.
3720         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3721             if (codec && !avctx->codec)
3722                 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
3723                     av_log(ic, AV_LOG_WARNING,
3724                            "Failed to open codec in %s\n",__FUNCTION__);
3725         }
3726         if (!options)
3727             av_dict_free(&thread_opt);
3728     }
3729
3730     for (i = 0; i < ic->nb_streams; i++) {
3731 #if FF_API_R_FRAME_RATE
3732         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3733 #endif
3734         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3735         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3736     }
3737
3738     read_size = 0;
3739     for (;;) {
3740         const AVPacket *pkt;
3741         int analyzed_all_streams;
3742         if (ff_check_interrupt(&ic->interrupt_callback)) {
3743             ret = AVERROR_EXIT;
3744             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3745             break;
3746         }
3747
3748         /* check if one codec still needs to be handled */
3749         for (i = 0; i < ic->nb_streams; i++) {
3750             int fps_analyze_framecount = 20;
3751             int count;
3752
3753             st = ic->streams[i];
3754             if (!has_codec_parameters(st, NULL))
3755                 break;
3756             /* If the timebase is coarse (like the usual millisecond precision
3757              * of mkv), we need to analyze more frames to reliably arrive at
3758              * the correct fps. */
3759             if (av_q2d(st->time_base) > 0.0005)
3760                 fps_analyze_framecount *= 2;
3761             if (!tb_unreliable(st->internal->avctx))
3762                 fps_analyze_framecount = 0;
3763             if (ic->fps_probe_size >= 0)
3764                 fps_analyze_framecount = ic->fps_probe_size;
3765             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3766                 fps_analyze_framecount = 0;
3767             /* variable fps and no guess at the real fps */
3768             count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3769                        st->info->codec_info_duration_fields/2 :
3770                        st->info->duration_count;
3771             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3772                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3773                 if (count < fps_analyze_framecount)
3774                     break;
3775             }
3776             // Look at the first 3 frames if there is evidence of frame delay
3777             // but the decoder delay is not set.
3778             if (st->info->frame_delay_evidence && count < 2 && st->internal->avctx->has_b_frames == 0)
3779                 break;
3780             if (!st->internal->avctx->extradata &&
3781                 (!st->internal->extract_extradata.inited ||
3782                  st->internal->extract_extradata.bsf) &&
3783                 extract_extradata_check(st))
3784                 break;
3785             if (st->first_dts == AV_NOPTS_VALUE &&
3786                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3787                 st->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
3788                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
3789                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
3790                 break;
3791         }
3792         analyzed_all_streams = 0;
3793         if (!missing_streams || !*missing_streams)
3794             if (i == ic->nb_streams) {
3795                 analyzed_all_streams = 1;
3796                 /* NOTE: If the format has no header, then we need to read some
3797                  * packets to get most of the streams, so we cannot stop here. */
3798                 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3799                     /* If we found the info for all the codecs, we can stop. */
3800                     ret = count;
3801                     av_log(ic, AV_LOG_DEBUG, "All info found\n");
3802                     flush_codecs = 0;
3803                     break;
3804                 }
3805             }
3806         /* We did not get all the codec info, but we read too much data. */
3807         if (read_size >= probesize) {
3808             ret = count;
3809             av_log(ic, AV_LOG_DEBUG,
3810                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3811             for (i = 0; i < ic->nb_streams; i++)
3812                 if (!ic->streams[i]->r_frame_rate.num &&
3813                     ic->streams[i]->info->duration_count <= 1 &&
3814                     ic->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
3815                     strcmp(ic->iformat->name, "image2"))
3816                     av_log(ic, AV_LOG_WARNING,
3817                            "Stream #%d: not enough frames to estimate rate; "
3818                            "consider increasing probesize\n", i);
3819             break;
3820         }
3821
3822         /* NOTE: A new stream can be added there if no header in file
3823          * (AVFMTCTX_NOHEADER). */
3824         ret = read_frame_internal(ic, &pkt1);
3825         if (ret == AVERROR(EAGAIN))
3826             continue;
3827
3828         if (ret < 0) {
3829             /* EOF or error*/
3830             eof_reached = 1;
3831             break;
3832         }
3833
3834         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3835             ret = ff_packet_list_put(&ic->internal->packet_buffer,
3836                                      &ic->internal->packet_buffer_end,
3837                                      &pkt1, 0);
3838             if (ret < 0)
3839                 goto unref_then_goto_end;
3840
3841             pkt = &ic->internal->packet_buffer_end->pkt;
3842         } else {
3843             pkt = &pkt1;
3844         }
3845
3846         st = ic->streams[pkt->stream_index];
3847         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3848             read_size += pkt->size;
3849
3850         avctx = st->internal->avctx;
3851         if (!st->internal->avctx_inited) {
3852             ret = avcodec_parameters_to_context(avctx, st->codecpar);
3853             if (ret < 0)
3854                 goto unref_then_goto_end;
3855             st->internal->avctx_inited = 1;
3856         }
3857
3858         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3859             /* check for non-increasing dts */
3860             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3861                 st->info->fps_last_dts >= pkt->dts) {
3862                 av_log(ic, AV_LOG_DEBUG,
3863                        "Non-increasing DTS in stream %d: packet %d with DTS "
3864                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3865                        st->index, st->info->fps_last_dts_idx,
3866                        st->info->fps_last_dts, st->codec_info_nb_frames,
3867                        pkt->dts);
3868                 st->info->fps_first_dts =
3869                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3870             }
3871             /* Check for a discontinuity in dts. If the difference in dts
3872              * is more than 1000 times the average packet duration in the
3873              * sequence, we treat it as a discontinuity. */
3874             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3875                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3876                 (pkt->dts - (uint64_t)st->info->fps_last_dts) / 1000 >
3877                 (st->info->fps_last_dts     - (uint64_t)st->info->fps_first_dts) /
3878                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3879                 av_log(ic, AV_LOG_WARNING,
3880                        "DTS discontinuity in stream %d: packet %d with DTS "
3881                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3882                        st->index, st->info->fps_last_dts_idx,
3883                        st->info->fps_last_dts, st->codec_info_nb_frames,
3884                        pkt->dts);
3885                 st->info->fps_first_dts =
3886                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3887             }
3888
3889             /* update stored dts values */
3890             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3891                 st->info->fps_first_dts     = pkt->dts;
3892                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3893             }
3894             st->info->fps_last_dts     = pkt->dts;
3895             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3896         }
3897         if (st->codec_info_nb_frames>1) {
3898             int64_t t = 0;
3899             int64_t limit;
3900
3901             if (st->time_base.den > 0)
3902                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3903             if (st->avg_frame_rate.num > 0)
3904                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3905
3906             if (   t == 0
3907                 && st->codec_info_nb_frames>30
3908                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3909                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3910                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3911
3912             if (analyzed_all_streams)                                limit = max_analyze_duration;
3913             else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3914             else                                                     limit = max_stream_analyze_duration;
3915
3916             if (t >= limit) {
3917                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3918                        limit,
3919                        t, pkt->stream_index);
3920                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3921                     av_packet_unref(&pkt1);
3922                 break;
3923             }
3924             if (pkt->duration) {
3925                 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3926                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3927                 } else
3928                     st->info->codec_info_duration += pkt->duration;
3929                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && avctx->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3930             }
3931         }
3932         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
3933 #if FF_API_R_FRAME_RATE
3934             ff_rfps_add_frame(ic, st, pkt->dts);
3935 #endif
3936             if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
3937                 st->info->frame_delay_evidence = 1;
3938         }
3939         if (!st->internal->avctx->extradata) {
3940             ret = extract_extradata(st, pkt);
3941             if (ret < 0)
3942                 goto unref_then_goto_end;
3943         }
3944
3945         /* If still no information, we try to open the codec and to
3946          * decompress the frame. We try to avoid that in most cases as
3947          * it takes longer and uses more memory. For MPEG-4, we need to
3948          * decompress for QuickTime.
3949          *
3950          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3951          * least one frame of codec data, this makes sure the codec initializes
3952          * the channel configuration and does not only trust the values from
3953          * the container. */
3954         try_decode_frame(ic, st, pkt,
3955                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3956
3957         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3958             av_packet_unref(&pkt1);
3959
3960         st->codec_info_nb_frames++;
3961         count++;
3962     }
3963
3964     if (eof_reached) {
3965         int stream_index;
3966         for (stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
3967             st = ic->streams[stream_index];
3968             avctx = st->internal->avctx;
3969             if (!has_codec_parameters(st, NULL)) {
3970                 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
3971                 if (codec && !avctx->codec) {
3972                     AVDictionary *opts = NULL;
3973                     if (ic->codec_whitelist)
3974                         av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
3975                     if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
3976                         av_log(ic, AV_LOG_WARNING,
3977                                "Failed to open codec in %s\n",__FUNCTION__);
3978                     av_dict_free(&opts);
3979                 }
3980             }
3981
3982             // EOF already reached while reading the stream above.
3983             // So continue with reoordering DTS with whatever delay we have.
3984             if (ic->internal->packet_buffer && !has_decode_delay_been_guessed(st)) {
3985                 update_dts_from_pts(ic, stream_index, ic->internal->packet_buffer);
3986             }
3987         }
3988     }
3989
3990     if (flush_codecs) {
3991         AVPacket empty_pkt = { 0 };
3992         int err = 0;
3993         av_init_packet(&empty_pkt);
3994
3995         for (i = 0; i < ic->nb_streams; i++) {
3996
3997             st = ic->streams[i];
3998
3999             /* flush the decoders */
4000             if (st->info->found_decoder == 1) {
4001                 do {
4002                     err = try_decode_frame(ic, st, &empty_pkt,
4003                                             (options && i < orig_nb_streams)
4004                                             ? &options[i] : NULL);
4005                 } while (err > 0 && !has_codec_parameters(st, NULL));
4006
4007                 if (err < 0) {
4008                     av_log(ic, AV_LOG_INFO,
4009                         "decoding for stream %d failed\n", st->index);
4010                 }
4011             }
4012         }
4013     }
4014
4015     ff_rfps_calculate(ic);
4016
4017     for (i = 0; i < ic->nb_streams; i++) {
4018         st = ic->streams[i];
4019         avctx = st->internal->avctx;
4020         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
4021             if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
4022                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
4023                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == avctx->pix_fmt)
4024                     avctx->codec_tag= tag;
4025             }
4026
4027             /* estimate average framerate if not set by demuxer */
4028             if (st->info->codec_info_duration_fields &&
4029                 !st->avg_frame_rate.num &&
4030                 st->info->codec_info_duration) {
4031                 int best_fps      = 0;
4032                 double best_error = 0.01;
4033                 AVRational codec_frame_rate = avctx->framerate;
4034
4035                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
4036                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
4037                     st->info->codec_info_duration        < 0)
4038                     continue;
4039                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4040                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
4041                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
4042
4043                 /* Round guessed framerate to a "standard" framerate if it's
4044                  * within 1% of the original estimate. */
4045                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
4046                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
4047                     double error       = fabs(av_q2d(st->avg_frame_rate) /
4048                                               av_q2d(std_fps) - 1);
4049
4050                     if (error < best_error) {
4051                         best_error = error;
4052                         best_fps   = std_fps.num;
4053                     }
4054
4055                     if (ic->internal->prefer_codec_framerate && codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
4056                         error       = fabs(av_q2d(codec_frame_rate) /
4057                                            av_q2d(std_fps) - 1);
4058                         if (error < best_error) {
4059                             best_error = error;
4060                             best_fps   = std_fps.num;
4061                         }
4062                     }
4063                 }
4064                 if (best_fps)
4065                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
4066                               best_fps, 12 * 1001, INT_MAX);
4067             }
4068
4069             if (!st->r_frame_rate.num) {
4070                 if (    avctx->time_base.den * (int64_t) st->time_base.num
4071                     <= avctx->time_base.num * avctx->ticks_per_frame * (uint64_t) st->time_base.den) {
4072                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den,
4073                               avctx->time_base.den, (int64_t)avctx->time_base.num * avctx->ticks_per_frame, INT_MAX);
4074                 } else {
4075                     st->r_frame_rate.num = st->time_base.den;
4076                     st->r_frame_rate.den = st->time_base.num;
4077                 }
4078             }
4079             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
4080                 AVRational hw_ratio = { avctx->height, avctx->width };
4081                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
4082                                                    hw_ratio);
4083             }
4084         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
4085             if (!avctx->bits_per_coded_sample)
4086                 avctx->bits_per_coded_sample =
4087                     av_get_bits_per_sample(avctx->codec_id);
4088             // set stream disposition based on audio service type
4089             switch (avctx->audio_service_type) {
4090             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
4091                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
4092                 break;
4093             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
4094                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
4095                 break;
4096             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
4097                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
4098                 break;
4099             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
4100                 st->disposition = AV_DISPOSITION_COMMENT;
4101                 break;
4102             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
4103                 st->disposition = AV_DISPOSITION_KARAOKE;
4104                 break;
4105             }
4106         }
4107     }
4108
4109     if (probesize)
4110         estimate_timings(ic, old_offset);
4111
4112     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
4113
4114     if (ret >= 0 && ic->nb_streams)
4115         /* We could not have all the codec parameters before EOF. */
4116         ret = -1;
4117     for (i = 0; i < ic->nb_streams; i++) {
4118         const char *errmsg;
4119         st = ic->streams[i];
4120
4121         /* if no packet was ever seen, update context now for has_codec_parameters */
4122         if (!st->internal->avctx_inited) {
4123             if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
4124                 st->codecpar->format == AV_SAMPLE_FMT_NONE)
4125                 st->codecpar->format = st->internal->avctx->sample_fmt;
4126             ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
4127             if (ret < 0)
4128                 goto find_stream_info_err;
4129         }
4130         if (!has_codec_parameters(st, &errmsg)) {
4131             char buf[256];
4132             avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
4133             av_log(ic, AV_LOG_WARNING,
4134                    "Could not find codec parameters for stream %d (%s): %s\n"
4135                    "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
4136                    i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
4137         } else {
4138             ret = 0;
4139         }
4140     }
4141
4142     compute_chapters_end(ic);
4143
4144     /* update the stream parameters from the internal codec contexts */
4145     for (i = 0; i < ic->nb_streams; i++) {
4146         st = ic->streams[i];
4147
4148         if (st->internal->avctx_inited) {
4149             int orig_w = st->codecpar->width;
4150             int orig_h = st->codecpar->height;
4151             ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
4152             if (ret < 0)
4153                 goto find_stream_info_err;
4154             ret = add_coded_side_data(st, st->internal->avctx);
4155             if (ret < 0)
4156                 goto find_stream_info_err;
4157 #if FF_API_LOWRES
4158             // The decoder might reduce the video size by the lowres factor.
4159             if (st->internal->avctx->lowres && orig_w) {
4160                 st->codecpar->width = orig_w;
4161                 st->codecpar->height = orig_h;
4162             }
4163 #endif
4164         }
4165
4166 #if FF_API_LAVF_AVCTX
4167 FF_DISABLE_DEPRECATION_WARNINGS
4168         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
4169         if (ret < 0)
4170             goto find_stream_info_err;
4171
4172 #if FF_API_LOWRES
4173         // The old API (AVStream.codec) "requires" the resolution to be adjusted
4174         // by the lowres factor.
4175         if (st->internal->avctx->lowres && st->internal->avctx->width) {
4176             st->codec->lowres = st->internal->avctx->lowres;
4177             st->codec->width = st->internal->avctx->width;
4178             st->codec->height = st->internal->avctx->height;
4179         }
4180 #endif
4181
4182         if (st->codec->codec_tag != MKTAG('t','m','c','d')) {
4183             st->codec->time_base = st->internal->avctx->time_base;
4184             st->codec->ticks_per_frame = st->internal->avctx->ticks_per_frame;
4185         }
4186         st->codec->framerate = st->avg_frame_rate;
4187
4188         if (st->internal->avctx->subtitle_header) {
4189             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
4190             if (!st->codec->subtitle_header)
4191                 goto find_stream_info_err;
4192             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
4193             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
4194                    st->codec->subtitle_header_size);
4195         }
4196
4197         // Fields unavailable in AVCodecParameters
4198         st->codec->coded_width = st->internal->avctx->coded_width;
4199         st->codec->coded_height = st->internal->avctx->coded_height;
4200         st->codec->properties = st->internal->avctx->properties;
4201 FF_ENABLE_DEPRECATION_WARNINGS
4202 #endif
4203
4204         st->internal->avctx_inited = 0;
4205     }
4206
4207 find_stream_info_err:
4208     for (i = 0; i < ic->nb_streams; i++) {
4209         st = ic->streams[i];
4210         if (st->info)
4211             av_freep(&st->info->duration_error);
4212         avcodec_close(ic->streams[i]->internal->avctx);
4213         av_freep(&ic->streams[i]->info);
4214         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
4215         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
4216     }
4217     if (ic->pb)
4218         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
4219                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
4220     return ret;
4221
4222 unref_then_goto_end:
4223     av_packet_unref(&pkt1);
4224     goto find_stream_info_err;
4225 }
4226
4227 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
4228 {
4229     int i, j;
4230
4231     for (i = 0; i < ic->nb_programs; i++) {
4232         if (ic->programs[i] == last) {
4233             last = NULL;
4234         } else {
4235             if (!last)
4236                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
4237                     if (ic->programs[i]->stream_index[j] == s)
4238                         return ic->programs[i];
4239         }
4240     }
4241     return NULL;
4242 }
4243
4244 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
4245                         int wanted_stream_nb, int related_stream,
4246                         AVCodec **decoder_ret, int flags)
4247 {
4248     int i, nb_streams = ic->nb_streams;
4249     int ret = AVERROR_STREAM_NOT_FOUND;
4250     int best_count = -1, best_multiframe = -1, best_disposition = -1;
4251     int count, multiframe, disposition;
4252     int64_t best_bitrate = -1;
4253     int64_t bitrate;
4254     unsigned *program = NULL;
4255     const AVCodec *decoder = NULL, *best_decoder = NULL;
4256
4257     if (related_stream >= 0 && wanted_stream_nb < 0) {
4258         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
4259         if (p) {
4260             program    = p->stream_index;
4261             nb_streams = p->nb_stream_indexes;
4262         }
4263     }
4264     for (i = 0; i < nb_streams; i++) {
4265         int real_stream_index = program ? program[i] : i;
4266         AVStream *st          = ic->streams[real_stream_index];
4267         AVCodecParameters *par = st->codecpar;
4268         if (par->codec_type != type)
4269             continue;
4270         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
4271             continue;
4272         if (type == AVMEDIA_TYPE_AUDIO && !(par->channels && par->sample_rate))
4273             continue;
4274         if (decoder_ret) {
4275             decoder = find_decoder(ic, st, par->codec_id);
4276             if (!decoder) {
4277                 if (ret < 0)
4278                     ret = AVERROR_DECODER_NOT_FOUND;
4279                 continue;
4280             }
4281         }
4282         disposition = !(st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED | AV_DISPOSITION_VISUAL_IMPAIRED))
4283                       + !! (st->disposition & AV_DISPOSITION_DEFAULT);
4284         count = st->codec_info_nb_frames;
4285         bitrate = par->bit_rate;
4286         multiframe = FFMIN(5, count);
4287         if ((best_disposition >  disposition) ||
4288             (best_disposition == disposition && best_multiframe >  multiframe) ||
4289             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate >  bitrate) ||
4290             (best_disposition == disposition && best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
4291             continue;
4292         best_disposition = disposition;
4293         best_count   = count;
4294         best_bitrate = bitrate;
4295         best_multiframe = multiframe;
4296         ret          = real_stream_index;
4297         best_decoder = decoder;
4298         if (program && i == nb_streams - 1 && ret < 0) {
4299             program    = NULL;
4300             nb_streams = ic->nb_streams;
4301             /* no related stream found, try again with everything */
4302             i = 0;
4303         }
4304     }
4305     if (decoder_ret)
4306         *decoder_ret = (AVCodec*)best_decoder;
4307     return ret;
4308 }
4309
4310 /*******************************************************/
4311
4312 int av_read_play(AVFormatContext *s)
4313 {
4314     if (s->iformat->read_play)
4315         return s->iformat->read_play(s);
4316     if (s->pb)
4317         return avio_pause(s->pb, 0);
4318     return AVERROR(ENOSYS);
4319 }
4320
4321 int av_read_pause(AVFormatContext *s)
4322 {
4323     if (s->iformat->read_pause)
4324         return s->iformat->read_pause(s);
4325     if (s->pb)
4326         return avio_pause(s->pb, 1);
4327     return AVERROR(ENOSYS);
4328 }
4329
4330 int ff_stream_encode_params_copy(AVStream *dst, const AVStream *src)
4331 {
4332     int ret, i;
4333
4334     dst->id                  = src->id;
4335     dst->time_base           = src->time_base;
4336     dst->nb_frames           = src->nb_frames;
4337     dst->disposition         = src->disposition;
4338     dst->sample_aspect_ratio = src->sample_aspect_ratio;
4339     dst->avg_frame_rate      = src->avg_frame_rate;
4340     dst->r_frame_rate        = src->r_frame_rate;
4341
4342     av_dict_free(&dst->metadata);
4343     ret = av_dict_copy(&dst->metadata, src->metadata, 0);
4344     if (ret < 0)
4345         return ret;
4346
4347     ret = avcodec_parameters_copy(dst->codecpar, src->codecpar);
4348     if (ret < 0)
4349         return ret;
4350
4351     /* Free existing side data*/
4352     for (i = 0; i < dst->nb_side_data; i++)
4353         av_free(dst->side_data[i].data);
4354     av_freep(&dst->side_data);
4355     dst->nb_side_data = 0;
4356
4357     /* Copy side data if present */
4358     if (src->nb_side_data) {
4359         dst->side_data = av_mallocz_array(src->nb_side_data,
4360                                           sizeof(AVPacketSideData));
4361         if (!dst->side_data)
4362             return AVERROR(ENOMEM);
4363         dst->nb_side_data = src->nb_side_data;
4364
4365         for (i = 0; i < src->nb_side_data; i++) {
4366             uint8_t *data = av_memdup(src->side_data[i].data,
4367                                       src->side_data[i].size);
4368             if (!data)
4369                 return AVERROR(ENOMEM);
4370             dst->side_data[i].type = src->side_data[i].type;
4371             dst->side_data[i].size = src->side_data[i].size;
4372             dst->side_data[i].data = data;
4373         }
4374     }
4375
4376 #if FF_API_LAVF_FFSERVER
4377 FF_DISABLE_DEPRECATION_WARNINGS
4378     av_freep(&dst->recommended_encoder_configuration);
4379     if (src->recommended_encoder_configuration) {
4380         const char *conf_str = src->recommended_encoder_configuration;
4381         dst->recommended_encoder_configuration = av_strdup(conf_str);
4382         if (!dst->recommended_encoder_configuration)
4383             return AVERROR(ENOMEM);
4384     }
4385 FF_ENABLE_DEPRECATION_WARNINGS
4386 #endif
4387
4388     return 0;
4389 }
4390
4391 static void free_stream(AVStream **pst)
4392 {
4393     AVStream *st = *pst;
4394     int i;
4395
4396     if (!st)
4397         return;
4398
4399     for (i = 0; i < st->nb_side_data; i++)
4400         av_freep(&st->side_data[i].data);
4401     av_freep(&st->side_data);
4402
4403     if (st->parser)
4404         av_parser_close(st->parser);
4405
4406     if (st->attached_pic.data)
4407         av_packet_unref(&st->attached_pic);
4408
4409     if (st->internal) {
4410         avcodec_free_context(&st->internal->avctx);
4411         av_bsf_free(&st->internal->bsfc);
4412         av_freep(&st->internal->priv_pts);
4413         av_bsf_free(&st->internal->extract_extradata.bsf);
4414         av_packet_free(&st->internal->extract_extradata.pkt);
4415     }
4416     av_freep(&st->internal);
4417
4418     av_dict_free(&st->metadata);
4419     avcodec_parameters_free(&st->codecpar);
4420     av_freep(&st->probe_data.buf);
4421     av_freep(&st->index_entries);
4422 #if FF_API_LAVF_AVCTX
4423 FF_DISABLE_DEPRECATION_WARNINGS
4424     avcodec_free_context(&st->codec);
4425 FF_ENABLE_DEPRECATION_WARNINGS
4426 #endif
4427     av_freep(&st->priv_data);
4428     if (st->info)
4429         av_freep(&st->info->duration_error);
4430     av_freep(&st->info);
4431 #if FF_API_LAVF_FFSERVER
4432 FF_DISABLE_DEPRECATION_WARNINGS
4433     av_freep(&st->recommended_encoder_configuration);
4434 FF_ENABLE_DEPRECATION_WARNINGS
4435 #endif
4436
4437     av_freep(pst);
4438 }
4439
4440 void ff_free_stream(AVFormatContext *s, AVStream *st)
4441 {
4442     av_assert0(s->nb_streams>0);
4443     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4444
4445     free_stream(&s->streams[ --s->nb_streams ]);
4446 }
4447
4448 void avformat_free_context(AVFormatContext *s)
4449 {
4450     int i;
4451
4452     if (!s)
4453         return;
4454
4455     if (s->oformat && s->oformat->deinit && s->internal->initialized)
4456         s->oformat->deinit(s);
4457
4458     av_opt_free(s);
4459     if (s->iformat && s->iformat->priv_class && s->priv_data)
4460         av_opt_free(s->priv_data);
4461     if (s->oformat && s->oformat->priv_class && s->priv_data)
4462         av_opt_free(s->priv_data);
4463
4464     for (i = 0; i < s->nb_streams; i++)
4465         free_stream(&s->streams[i]);
4466     s->nb_streams = 0;
4467
4468     for (i = 0; i < s->nb_programs; i++) {
4469         av_dict_free(&s->programs[i]->metadata);
4470         av_freep(&s->programs[i]->stream_index);
4471         av_freep(&s->programs[i]);
4472     }
4473     s->nb_programs = 0;
4474
4475     av_freep(&s->programs);
4476     av_freep(&s->priv_data);
4477     while (s->nb_chapters--) {
4478         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4479         av_freep(&s->chapters[s->nb_chapters]);
4480     }
4481     av_freep(&s->chapters);
4482     av_dict_free(&s->metadata);
4483     av_dict_free(&s->internal->id3v2_meta);
4484     av_freep(&s->streams);
4485     flush_packet_queue(s);
4486     av_freep(&s->internal);
4487     av_freep(&s->url);
4488     av_free(s);
4489 }
4490
4491 void avformat_close_input(AVFormatContext **ps)
4492 {
4493     AVFormatContext *s;
4494     AVIOContext *pb;
4495
4496     if (!ps || !*ps)
4497         return;
4498
4499     s  = *ps;
4500     pb = s->pb;
4501
4502     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4503         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4504         pb = NULL;
4505
4506     flush_packet_queue(s);
4507
4508     if (s->iformat)
4509         if (s->iformat->read_close)
4510             s->iformat->read_close(s);
4511
4512     avformat_free_context(s);
4513
4514     *ps = NULL;
4515
4516     avio_close(pb);
4517 }
4518
4519 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4520 {
4521     AVStream *st;
4522     int i;
4523     AVStream **streams;
4524
4525     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4526         if (s->max_streams < INT_MAX/sizeof(*streams))
4527             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);
4528         return NULL;
4529     }
4530     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4531     if (!streams)
4532         return NULL;
4533     s->streams = streams;
4534
4535     st = av_mallocz(sizeof(AVStream));
4536     if (!st)
4537         return NULL;
4538     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4539         av_free(st);
4540         return NULL;
4541     }
4542     st->info->last_dts = AV_NOPTS_VALUE;
4543
4544 #if FF_API_LAVF_AVCTX
4545 FF_DISABLE_DEPRECATION_WARNINGS
4546     st->codec = avcodec_alloc_context3(c);
4547     if (!st->codec) {
4548         av_free(st->info);
4549         av_free(st);
4550         return NULL;
4551     }
4552 FF_ENABLE_DEPRECATION_WARNINGS
4553 #endif
4554
4555     st->internal = av_mallocz(sizeof(*st->internal));
4556     if (!st->internal)
4557         goto fail;
4558
4559     st->codecpar = avcodec_parameters_alloc();
4560     if (!st->codecpar)
4561         goto fail;
4562
4563     st->internal->avctx = avcodec_alloc_context3(NULL);
4564     if (!st->internal->avctx)
4565         goto fail;
4566
4567     if (s->iformat) {
4568 #if FF_API_LAVF_AVCTX
4569 FF_DISABLE_DEPRECATION_WARNINGS
4570         /* no default bitrate if decoding */
4571         st->codec->bit_rate = 0;
4572 FF_ENABLE_DEPRECATION_WARNINGS
4573 #endif
4574
4575         /* default pts setting is MPEG-like */
4576         avpriv_set_pts_info(st, 33, 1, 90000);
4577         /* we set the current DTS to 0 so that formats without any timestamps
4578          * but durations get some timestamps, formats with some unknown
4579          * timestamps have their first few packets buffered and the
4580          * timestamps corrected before they are returned to the user */
4581         st->cur_dts = RELATIVE_TS_BASE;
4582     } else {
4583         st->cur_dts = AV_NOPTS_VALUE;
4584     }
4585
4586     st->index      = s->nb_streams;
4587     st->start_time = AV_NOPTS_VALUE;
4588     st->duration   = AV_NOPTS_VALUE;
4589     st->first_dts     = AV_NOPTS_VALUE;
4590     st->probe_packets = s->max_probe_packets;
4591     st->pts_wrap_reference = AV_NOPTS_VALUE;
4592     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4593
4594     st->last_IP_pts = AV_NOPTS_VALUE;
4595     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4596     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4597         st->pts_buffer[i] = AV_NOPTS_VALUE;
4598
4599     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4600
4601 #if FF_API_R_FRAME_RATE
4602     st->info->last_dts      = AV_NOPTS_VALUE;
4603 #endif
4604     st->info->fps_first_dts = AV_NOPTS_VALUE;
4605     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4606
4607     st->inject_global_side_data = s->internal->inject_global_side_data;
4608
4609     st->internal->need_context_update = 1;
4610
4611     s->streams[s->nb_streams++] = st;
4612     return st;
4613 fail:
4614     free_stream(&st);
4615     return NULL;
4616 }
4617
4618 AVProgram *av_new_program(AVFormatContext *ac, int id)
4619 {
4620     AVProgram *program = NULL;
4621     int i;
4622
4623     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4624
4625     for (i = 0; i < ac->nb_programs; i++)
4626         if (ac->programs[i]->id == id)
4627             program = ac->programs[i];
4628
4629     if (!program) {
4630         program = av_mallocz(sizeof(AVProgram));
4631         if (!program)
4632             return NULL;
4633         dynarray_add(&ac->programs, &ac->nb_programs, program);
4634         program->discard = AVDISCARD_NONE;
4635         program->pmt_version = -1;
4636     }
4637     program->id = id;
4638     program->pts_wrap_reference = AV_NOPTS_VALUE;
4639     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4640
4641     program->start_time =
4642     program->end_time   = AV_NOPTS_VALUE;
4643
4644     return program;
4645 }
4646
4647 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4648                               int64_t start, int64_t end, const char *title)
4649 {
4650     AVChapter *chapter = NULL;
4651     int i;
4652
4653     if (end != AV_NOPTS_VALUE && start > end) {
4654         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4655         return NULL;
4656     }
4657
4658     for (i = 0; i < s->nb_chapters; i++)
4659         if (s->chapters[i]->id == id)
4660             chapter = s->chapters[i];
4661
4662     if (!chapter) {
4663         chapter = av_mallocz(sizeof(AVChapter));
4664         if (!chapter)
4665             return NULL;
4666         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4667     }
4668     av_dict_set(&chapter->metadata, "title", title, 0);
4669     chapter->id        = id;
4670     chapter->time_base = time_base;
4671     chapter->start     = start;
4672     chapter->end       = end;
4673
4674     return chapter;
4675 }
4676
4677 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4678 {
4679     int i, j;
4680     AVProgram *program = NULL;
4681     void *tmp;
4682
4683     if (idx >= ac->nb_streams) {
4684         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4685         return;
4686     }
4687
4688     for (i = 0; i < ac->nb_programs; i++) {
4689         if (ac->programs[i]->id != progid)
4690             continue;
4691         program = ac->programs[i];
4692         for (j = 0; j < program->nb_stream_indexes; j++)
4693             if (program->stream_index[j] == idx)
4694                 return;
4695
4696         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4697         if (!tmp)
4698             return;
4699         program->stream_index = tmp;
4700         program->stream_index[program->nb_stream_indexes++] = idx;
4701         return;
4702     }
4703 }
4704
4705 uint64_t ff_ntp_time(void)
4706 {
4707     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4708 }
4709
4710 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4711 {
4712     uint64_t ntp_ts, frac_part, sec;
4713     uint32_t usec;
4714
4715     //current ntp time in seconds and micro seconds
4716     sec = ntp_time_us / 1000000;
4717     usec = ntp_time_us % 1000000;
4718
4719     //encoding in ntp timestamp format
4720     frac_part = usec * 0xFFFFFFFFULL;
4721     frac_part /= 1000000;
4722
4723     if (sec > 0xFFFFFFFFULL)
4724         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4725
4726     ntp_ts = sec << 32;
4727     ntp_ts |= frac_part;
4728
4729     return ntp_ts;
4730 }
4731
4732 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4733 {
4734     const char *p;
4735     char *q, buf1[20], c;
4736     int nd, len, percentd_found;
4737
4738     q = buf;
4739     p = path;
4740     percentd_found = 0;
4741     for (;;) {
4742         c = *p++;
4743         if (c == '\0')
4744             break;
4745         if (c == '%') {
4746             do {
4747                 nd = 0;
4748                 while (av_isdigit(*p))
4749                     nd = nd * 10 + *p++ - '0';
4750                 c = *p++;
4751             } while (av_isdigit(c));
4752
4753             switch (c) {
4754             case '%':
4755                 goto addchar;
4756             case 'd':
4757                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4758                     goto fail;
4759                 percentd_found = 1;
4760                 if (number < 0)
4761                     nd += 1;
4762                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4763                 len = strlen(buf1);
4764                 if ((q - buf + len) > buf_size - 1)
4765                     goto fail;
4766                 memcpy(q, buf1, len);
4767                 q += len;
4768                 break;
4769             default:
4770                 goto fail;
4771             }
4772         } else {
4773 addchar:
4774             if ((q - buf) < buf_size - 1)
4775                 *q++ = c;
4776         }
4777     }
4778     if (!percentd_found)
4779         goto fail;
4780     *q = '\0';
4781     return 0;
4782 fail:
4783     *q = '\0';
4784     return -1;
4785 }
4786
4787 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4788 {
4789     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4790 }
4791
4792 void av_url_split(char *proto, int proto_size,
4793                   char *authorization, int authorization_size,
4794                   char *hostname, int hostname_size,
4795                   int *port_ptr, char *path, int path_size, const char *url)
4796 {
4797     const char *p, *ls, *at, *at2, *col, *brk;
4798
4799     if (port_ptr)
4800         *port_ptr = -1;
4801     if (proto_size > 0)
4802         proto[0] = 0;
4803     if (authorization_size > 0)
4804         authorization[0] = 0;
4805     if (hostname_size > 0)
4806         hostname[0] = 0;
4807     if (path_size > 0)
4808         path[0] = 0;
4809
4810     /* parse protocol */
4811     if ((p = strchr(url, ':'))) {
4812         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4813         p++; /* skip ':' */
4814         if (*p == '/')
4815             p++;
4816         if (*p == '/')
4817             p++;
4818     } else {
4819         /* no protocol means plain filename */
4820         av_strlcpy(path, url, path_size);
4821         return;
4822     }
4823
4824     /* separate path from hostname */
4825     ls = p + strcspn(p, "/?#");
4826     av_strlcpy(path, ls, path_size);
4827
4828     /* the rest is hostname, use that to parse auth/port */
4829     if (ls != p) {
4830         /* authorization (user[:pass]@hostname) */
4831         at2 = p;
4832         while ((at = strchr(p, '@')) && at < ls) {
4833             av_strlcpy(authorization, at2,
4834                        FFMIN(authorization_size, at + 1 - at2));
4835             p = at + 1; /* skip '@' */
4836         }
4837
4838         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4839             /* [host]:port */
4840             av_strlcpy(hostname, p + 1,
4841                        FFMIN(hostname_size, brk - p));
4842             if (brk[1] == ':' && port_ptr)
4843                 *port_ptr = atoi(brk + 2);
4844         } else if ((col = strchr(p, ':')) && col < ls) {
4845             av_strlcpy(hostname, p,
4846                        FFMIN(col + 1 - p, hostname_size));
4847             if (port_ptr)
4848                 *port_ptr = atoi(col + 1);
4849         } else
4850             av_strlcpy(hostname, p,
4851                        FFMIN(ls + 1 - p, hostname_size));
4852     }
4853 }
4854
4855 int ff_mkdir_p(const char *path)
4856 {
4857     int ret = 0;
4858     char *temp = av_strdup(path);
4859     char *pos = temp;
4860     char tmp_ch = '\0';
4861
4862     if (!path || !temp) {
4863         return -1;
4864     }
4865
4866     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4867         pos++;
4868     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4869         pos += 2;
4870     }
4871
4872     for ( ; *pos != '\0'; ++pos) {
4873         if (*pos == '/' || *pos == '\\') {
4874             tmp_ch = *pos;
4875             *pos = '\0';
4876             ret = mkdir(temp, 0755);
4877             *pos = tmp_ch;
4878         }
4879     }
4880
4881     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4882         ret = mkdir(temp, 0755);
4883     }
4884
4885     av_free(temp);
4886     return ret;
4887 }
4888
4889 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4890 {
4891     int i;
4892     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4893                                            '4', '5', '6', '7',
4894                                            '8', '9', 'A', 'B',
4895                                            'C', 'D', 'E', 'F' };
4896     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4897                                            '4', '5', '6', '7',
4898                                            '8', '9', 'a', 'b',
4899                                            'c', 'd', 'e', 'f' };
4900     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4901
4902     for (i = 0; i < s; i++) {
4903         buff[i * 2]     = hex_table[src[i] >> 4];
4904         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4905     }
4906
4907     return buff;
4908 }
4909
4910 int ff_hex_to_data(uint8_t *data, const char *p)
4911 {
4912     int c, len, v;
4913
4914     len = 0;
4915     v   = 1;
4916     for (;;) {
4917         p += strspn(p, SPACE_CHARS);
4918         if (*p == '\0')
4919             break;
4920         c = av_toupper((unsigned char) *p++);
4921         if (c >= '0' && c <= '9')
4922             c = c - '0';
4923         else if (c >= 'A' && c <= 'F')
4924             c = c - 'A' + 10;
4925         else
4926             break;
4927         v = (v << 4) | c;
4928         if (v & 0x100) {
4929             if (data)
4930                 data[len] = v;
4931             len++;
4932             v = 1;
4933         }
4934     }
4935     return len;
4936 }
4937
4938 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4939                          unsigned int pts_num, unsigned int pts_den)
4940 {
4941     AVRational new_tb;
4942     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4943         if (new_tb.num != pts_num)
4944             av_log(NULL, AV_LOG_DEBUG,
4945                    "st:%d removing common factor %d from timebase\n",
4946                    s->index, pts_num / new_tb.num);
4947     } else
4948         av_log(NULL, AV_LOG_WARNING,
4949                "st:%d has too large timebase, reducing\n", s->index);
4950
4951     if (new_tb.num <= 0 || new_tb.den <= 0) {
4952         av_log(NULL, AV_LOG_ERROR,
4953                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4954                new_tb.num, new_tb.den,
4955                s->index);
4956         return;
4957     }
4958     s->time_base     = new_tb;
4959 #if FF_API_LAVF_AVCTX
4960 FF_DISABLE_DEPRECATION_WARNINGS
4961     s->codec->pkt_timebase = new_tb;
4962 FF_ENABLE_DEPRECATION_WARNINGS
4963 #endif
4964     s->internal->avctx->pkt_timebase = new_tb;
4965     s->pts_wrap_bits = pts_wrap_bits;
4966 }
4967
4968 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4969                         void *context)
4970 {
4971     const char *ptr = str;
4972
4973     /* Parse key=value pairs. */
4974     for (;;) {
4975         const char *key;
4976         char *dest = NULL, *dest_end;
4977         int key_len, dest_len = 0;
4978
4979         /* Skip whitespace and potential commas. */
4980         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4981             ptr++;
4982         if (!*ptr)
4983             break;
4984
4985         key = ptr;
4986
4987         if (!(ptr = strchr(key, '=')))
4988             break;
4989         ptr++;
4990         key_len = ptr - key;
4991
4992         callback_get_buf(context, key, key_len, &dest, &dest_len);
4993         dest_end = dest + dest_len - 1;
4994
4995         if (*ptr == '\"') {
4996             ptr++;
4997             while (*ptr && *ptr != '\"') {
4998                 if (*ptr == '\\') {
4999                     if (!ptr[1])
5000                         break;
5001                     if (dest && dest < dest_end)
5002                         *dest++ = ptr[1];
5003                     ptr += 2;
5004                 } else {
5005                     if (dest && dest < dest_end)
5006                         *dest++ = *ptr;
5007                     ptr++;
5008                 }
5009             }
5010             if (*ptr == '\"')
5011                 ptr++;
5012         } else {
5013             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5014                 if (dest && dest < dest_end)
5015                     *dest++ = *ptr;
5016         }
5017         if (dest)
5018             *dest = 0;
5019     }
5020 }
5021
5022 int ff_find_stream_index(AVFormatContext *s, int id)
5023 {
5024     int i;
5025     for (i = 0; i < s->nb_streams; i++)
5026         if (s->streams[i]->id == id)
5027             return i;
5028     return -1;
5029 }
5030
5031 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5032                          int std_compliance)
5033 {
5034     if (ofmt) {
5035         unsigned int codec_tag;
5036         if (ofmt->query_codec)
5037             return ofmt->query_codec(codec_id, std_compliance);
5038         else if (ofmt->codec_tag)
5039             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5040         else if (codec_id == ofmt->video_codec ||
5041                  codec_id == ofmt->audio_codec ||
5042                  codec_id == ofmt->subtitle_codec ||
5043                  codec_id == ofmt->data_codec)
5044             return 1;
5045     }
5046     return AVERROR_PATCHWELCOME;
5047 }
5048
5049 int avformat_network_init(void)
5050 {
5051 #if CONFIG_NETWORK
5052     int ret;
5053     if ((ret = ff_network_init()) < 0)
5054         return ret;
5055     if ((ret = ff_tls_init()) < 0)
5056         return ret;
5057 #endif
5058     return 0;
5059 }
5060
5061 int avformat_network_deinit(void)
5062 {
5063 #if CONFIG_NETWORK
5064     ff_network_close();
5065     ff_tls_deinit();
5066 #endif
5067     return 0;
5068 }
5069
5070 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5071                         uint64_t channel_layout, int32_t sample_rate,
5072                         int32_t width, int32_t height)
5073 {
5074     uint32_t flags = 0;
5075     int size = 4;
5076     uint8_t *data;
5077     if (!pkt)
5078         return AVERROR(EINVAL);
5079     if (channels) {
5080         size  += 4;
5081         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5082     }
5083     if (channel_layout) {
5084         size  += 8;
5085         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5086     }
5087     if (sample_rate) {
5088         size  += 4;
5089         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5090     }
5091     if (width || height) {
5092         size  += 8;
5093         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5094     }
5095     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5096     if (!data)
5097         return AVERROR(ENOMEM);
5098     bytestream_put_le32(&data, flags);
5099     if (channels)
5100         bytestream_put_le32(&data, channels);
5101     if (channel_layout)
5102         bytestream_put_le64(&data, channel_layout);
5103     if (sample_rate)
5104         bytestream_put_le32(&data, sample_rate);
5105     if (width || height) {
5106         bytestream_put_le32(&data, width);
5107         bytestream_put_le32(&data, height);
5108     }
5109     return 0;
5110 }
5111
5112 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5113 {
5114     AVRational undef = {0, 1};
5115     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5116     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5117     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5118
5119     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5120                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5121     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5122         stream_sample_aspect_ratio = undef;
5123
5124     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5125                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5126     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5127         frame_sample_aspect_ratio = undef;
5128
5129     if (stream_sample_aspect_ratio.num)
5130         return stream_sample_aspect_ratio;
5131     else
5132         return frame_sample_aspect_ratio;
5133 }
5134
5135 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5136 {
5137     AVRational fr = st->r_frame_rate;
5138     AVRational codec_fr = st->internal->avctx->framerate;
5139     AVRational   avg_fr = st->avg_frame_rate;
5140
5141     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5142         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5143         fr = avg_fr;
5144     }
5145
5146
5147     if (st->internal->avctx->ticks_per_frame > 1) {
5148         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5149             (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))
5150             fr = codec_fr;
5151     }
5152
5153     return fr;
5154 }
5155
5156 /**
5157  * Matches a stream specifier (but ignores requested index).
5158  *
5159  * @param indexptr set to point to the requested stream index if there is one
5160  *
5161  * @return <0 on error
5162  *         0  if st is NOT a matching stream
5163  *         >0 if st is a matching stream
5164  */
5165 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5166                                   const char *spec, const char **indexptr, AVProgram **p)
5167 {
5168     int match = 1;                      /* Stores if the specifier matches so far. */
5169     while (*spec) {
5170         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5171             if (indexptr)
5172                 *indexptr = spec;
5173             return match;
5174         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5175                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5176             enum AVMediaType type;
5177             int nopic = 0;
5178
5179             switch (*spec++) {
5180             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5181             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5182             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5183             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5184             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5185             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5186             default:  av_assert0(0);
5187             }
5188             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5189                 return AVERROR(EINVAL);
5190
5191 #if FF_API_LAVF_AVCTX
5192 FF_DISABLE_DEPRECATION_WARNINGS
5193             if (type != st->codecpar->codec_type
5194                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5195                 match = 0;
5196     FF_ENABLE_DEPRECATION_WARNINGS
5197 #else
5198             if (type != st->codecpar->codec_type)
5199                 match = 0;
5200 #endif
5201             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5202                 match = 0;
5203         } else if (*spec == 'p' && *(spec + 1) == ':') {
5204             int prog_id, i, j;
5205             int found = 0;
5206             char *endptr;
5207             spec += 2;
5208             prog_id = strtol(spec, &endptr, 0);
5209             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5210             if (spec == endptr || (*endptr && *endptr++ != ':'))
5211                 return AVERROR(EINVAL);
5212             spec = endptr;
5213             if (match) {
5214                 for (i = 0; i < s->nb_programs; i++) {
5215                     if (s->programs[i]->id != prog_id)
5216                         continue;
5217
5218                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5219                         if (st->index == s->programs[i]->stream_index[j]) {
5220                             found = 1;
5221                             if (p)
5222                                 *p = s->programs[i];
5223                             i = s->nb_programs;
5224                             break;
5225                         }
5226                     }
5227                 }
5228             }
5229             if (!found)
5230                 match = 0;
5231         } else if (*spec == '#' ||
5232                    (*spec == 'i' && *(spec + 1) == ':')) {
5233             int stream_id;
5234             char *endptr;
5235             spec += 1 + (*spec == 'i');
5236             stream_id = strtol(spec, &endptr, 0);
5237             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5238                 return AVERROR(EINVAL);
5239             return match && (stream_id == st->id);
5240         } else if (*spec == 'm' && *(spec + 1) == ':') {
5241             AVDictionaryEntry *tag;
5242             char *key, *val;
5243             int ret;
5244
5245             if (match) {
5246                spec += 2;
5247                val = strchr(spec, ':');
5248
5249                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5250                if (!key)
5251                    return AVERROR(ENOMEM);
5252
5253                tag = av_dict_get(st->metadata, key, NULL, 0);
5254                if (tag) {
5255                    if (!val || !strcmp(tag->value, val + 1))
5256                        ret = 1;
5257                    else
5258                        ret = 0;
5259                } else
5260                    ret = 0;
5261
5262                av_freep(&key);
5263             }
5264             return match && ret;
5265         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5266             AVCodecParameters *par = st->codecpar;
5267 #if FF_API_LAVF_AVCTX
5268 FF_DISABLE_DEPRECATION_WARNINGS
5269             AVCodecContext *codec = st->codec;
5270 FF_ENABLE_DEPRECATION_WARNINGS
5271 #endif
5272             int val;
5273             switch (par->codec_type) {
5274             case AVMEDIA_TYPE_AUDIO:
5275                 val = par->sample_rate && par->channels;
5276 #if FF_API_LAVF_AVCTX
5277                 val = val || (codec->sample_rate && codec->channels);
5278 #endif
5279                 if (par->format == AV_SAMPLE_FMT_NONE
5280 #if FF_API_LAVF_AVCTX
5281                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5282 #endif
5283                     )
5284                     return 0;
5285                 break;
5286             case AVMEDIA_TYPE_VIDEO:
5287                 val = par->width && par->height;
5288 #if FF_API_LAVF_AVCTX
5289                 val = val || (codec->width && codec->height);
5290 #endif
5291                 if (par->format == AV_PIX_FMT_NONE
5292 #if FF_API_LAVF_AVCTX
5293                     && codec->pix_fmt == AV_PIX_FMT_NONE
5294 #endif
5295                     )
5296                     return 0;
5297                 break;
5298             case AVMEDIA_TYPE_UNKNOWN:
5299                 val = 0;
5300                 break;
5301             default:
5302                 val = 1;
5303                 break;
5304             }
5305 #if FF_API_LAVF_AVCTX
5306             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5307 #else
5308             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5309 #endif
5310         } else {
5311             return AVERROR(EINVAL);
5312         }
5313     }
5314
5315     return match;
5316 }
5317
5318
5319 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5320                                     const char *spec)
5321 {
5322     int ret, index;
5323     char *endptr;
5324     const char *indexptr = NULL;
5325     AVProgram *p = NULL;
5326     int nb_streams;
5327
5328     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5329     if (ret < 0)
5330         goto error;
5331
5332     if (!indexptr)
5333         return ret;
5334
5335     index = strtol(indexptr, &endptr, 0);
5336     if (*endptr) {                  /* We can't have anything after the requested index. */
5337         ret = AVERROR(EINVAL);
5338         goto error;
5339     }
5340
5341     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5342     if (spec == indexptr)
5343         return (index == st->index);
5344
5345     /* If we requested a matching stream index, we have to ensure st is that. */
5346     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5347     for (int i = 0; i < nb_streams && index >= 0; i++) {
5348         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5349         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5350         if (ret < 0)
5351             goto error;
5352         if (ret > 0 && index-- == 0 && st == candidate)
5353             return 1;
5354     }
5355     return 0;
5356
5357 error:
5358     if (ret == AVERROR(EINVAL))
5359         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5360     return ret;
5361 }
5362
5363 int ff_generate_avci_extradata(AVStream *st)
5364 {
5365     static const uint8_t avci100_1080p_extradata[] = {
5366         // SPS
5367         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5368         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5369         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5370         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5371         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5372         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5373         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5374         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5375         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5376         // PPS
5377         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5378         0xd0
5379     };
5380     static const uint8_t avci100_1080i_extradata[] = {
5381         // SPS
5382         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5383         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5384         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5385         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5386         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5387         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5388         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5389         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5390         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5391         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5392         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5393         // PPS
5394         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5395         0xd0
5396     };
5397     static const uint8_t avci50_1080p_extradata[] = {
5398         // SPS
5399         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5400         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5401         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5402         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5403         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5404         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5405         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5406         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5407         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5408         // PPS
5409         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5410         0x11
5411     };
5412     static const uint8_t avci50_1080i_extradata[] = {
5413         // SPS
5414         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5415         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5416         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5417         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5418         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5419         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5420         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5421         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5422         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5423         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5424         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5425         // PPS
5426         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5427         0x11
5428     };
5429     static const uint8_t avci100_720p_extradata[] = {
5430         // SPS
5431         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5432         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5433         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5434         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5435         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5436         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5437         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5438         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5439         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5440         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5441         // PPS
5442         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5443         0x11
5444     };
5445     static const uint8_t avci50_720p_extradata[] = {
5446         // SPS
5447         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5448         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5449         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5450         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5451         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5452         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5453         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5454         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5455         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5456         // PPS
5457         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5458         0x11
5459     };
5460
5461     const uint8_t *data = NULL;
5462     int ret, size       = 0;
5463
5464     if (st->codecpar->width == 1920) {
5465         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5466             data = avci100_1080p_extradata;
5467             size = sizeof(avci100_1080p_extradata);
5468         } else {
5469             data = avci100_1080i_extradata;
5470             size = sizeof(avci100_1080i_extradata);
5471         }
5472     } else if (st->codecpar->width == 1440) {
5473         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5474             data = avci50_1080p_extradata;
5475             size = sizeof(avci50_1080p_extradata);
5476         } else {
5477             data = avci50_1080i_extradata;
5478             size = sizeof(avci50_1080i_extradata);
5479         }
5480     } else if (st->codecpar->width == 1280) {
5481         data = avci100_720p_extradata;
5482         size = sizeof(avci100_720p_extradata);
5483     } else if (st->codecpar->width == 960) {
5484         data = avci50_720p_extradata;
5485         size = sizeof(avci50_720p_extradata);
5486     }
5487
5488     if (!size)
5489         return 0;
5490
5491     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5492         return ret;
5493     memcpy(st->codecpar->extradata, data, size);
5494
5495     return 0;
5496 }
5497
5498 uint8_t *av_stream_get_side_data(const AVStream *st,
5499                                  enum AVPacketSideDataType type, int *size)
5500 {
5501     int i;
5502
5503     for (i = 0; i < st->nb_side_data; i++) {
5504         if (st->side_data[i].type == type) {
5505             if (size)
5506                 *size = st->side_data[i].size;
5507             return st->side_data[i].data;
5508         }
5509     }
5510     if (size)
5511         *size = 0;
5512     return NULL;
5513 }
5514
5515 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5516                             uint8_t *data, size_t size)
5517 {
5518     AVPacketSideData *sd, *tmp;
5519     int i;
5520
5521     for (i = 0; i < st->nb_side_data; i++) {
5522         sd = &st->side_data[i];
5523
5524         if (sd->type == type) {
5525             av_freep(&sd->data);
5526             sd->data = data;
5527             sd->size = size;
5528             return 0;
5529         }
5530     }
5531
5532     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5533         return AVERROR(ERANGE);
5534
5535     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5536     if (!tmp) {
5537         return AVERROR(ENOMEM);
5538     }
5539
5540     st->side_data = tmp;
5541     st->nb_side_data++;
5542
5543     sd = &st->side_data[st->nb_side_data - 1];
5544     sd->type = type;
5545     sd->data = data;
5546     sd->size = size;
5547
5548     return 0;
5549 }
5550
5551 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5552                                  int size)
5553 {
5554     int ret;
5555     uint8_t *data = av_malloc(size);
5556
5557     if (!data)
5558         return NULL;
5559
5560     ret = av_stream_add_side_data(st, type, data, size);
5561     if (ret < 0) {
5562         av_freep(&data);
5563         return NULL;
5564     }
5565
5566     return data;
5567 }
5568
5569 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5570 {
5571     int ret;
5572     const AVBitStreamFilter *bsf;
5573     AVBSFContext *bsfc;
5574
5575     av_assert0(!st->internal->bsfc);
5576
5577     if (!(bsf = av_bsf_get_by_name(name))) {
5578         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
5579         return AVERROR_BSF_NOT_FOUND;
5580     }
5581
5582     if ((ret = av_bsf_alloc(bsf, &bsfc)) < 0)
5583         return ret;
5584
5585     bsfc->time_base_in = st->time_base;
5586     if ((ret = avcodec_parameters_copy(bsfc->par_in, st->codecpar)) < 0) {
5587         av_bsf_free(&bsfc);
5588         return ret;
5589     }
5590
5591     if (args && bsfc->filter->priv_class) {
5592         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5593         const char * shorthand[2] = {NULL};
5594
5595         if (opt)
5596             shorthand[0] = opt->name;
5597
5598         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5599             av_bsf_free(&bsfc);
5600             return ret;
5601         }
5602     }
5603
5604     if ((ret = av_bsf_init(bsfc)) < 0) {
5605         av_bsf_free(&bsfc);
5606         return ret;
5607     }
5608
5609     st->internal->bsfc = bsfc;
5610
5611     av_log(NULL, AV_LOG_VERBOSE,
5612            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5613            name, args ? args : "");
5614     return 1;
5615 }
5616
5617 #if FF_API_OLD_BSF
5618 FF_DISABLE_DEPRECATION_WARNINGS
5619 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5620                                AVBitStreamFilterContext *bsfc)
5621 {
5622     int ret = 0;
5623     while (bsfc) {
5624         AVPacket new_pkt = *pkt;
5625         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5626                                            &new_pkt.data, &new_pkt.size,
5627                                            pkt->data, pkt->size,
5628                                            pkt->flags & AV_PKT_FLAG_KEY);
5629         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5630             av_packet_unref(pkt);
5631             memset(pkt, 0, sizeof(*pkt));
5632             return 0;
5633         }
5634         if(a == 0 && new_pkt.data != pkt->data) {
5635             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
5636             if (t) {
5637                 memcpy(t, new_pkt.data, new_pkt.size);
5638                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5639                 new_pkt.data = t;
5640                 new_pkt.buf = NULL;
5641                 a = 1;
5642             } else {
5643                 a = AVERROR(ENOMEM);
5644             }
5645         }
5646         if (a > 0) {
5647             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5648                                            av_buffer_default_free, NULL, 0);
5649             if (new_pkt.buf) {
5650                 pkt->side_data = NULL;
5651                 pkt->side_data_elems = 0;
5652                 av_packet_unref(pkt);
5653             } else {
5654                 av_freep(&new_pkt.data);
5655                 a = AVERROR(ENOMEM);
5656             }
5657         }
5658         if (a < 0) {
5659             av_log(codec, AV_LOG_ERROR,
5660                    "Failed to open bitstream filter %s for stream %d with codec %s",
5661                    bsfc->filter->name, pkt->stream_index,
5662                    codec->codec ? codec->codec->name : "copy");
5663             ret = a;
5664             break;
5665         }
5666         *pkt = new_pkt;
5667
5668         bsfc = bsfc->next;
5669     }
5670     return ret;
5671 }
5672 FF_ENABLE_DEPRECATION_WARNINGS
5673 #endif
5674
5675 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5676 {
5677     if (!s->oformat)
5678         return AVERROR(EINVAL);
5679
5680     if (!(s->oformat->flags & AVFMT_NOFILE))
5681         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5682     return 0;
5683 }
5684
5685 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5686 {
5687     if (*pb)
5688         s->io_close(s, *pb);
5689     *pb = NULL;
5690 }
5691
5692 int ff_is_http_proto(char *filename) {
5693     const char *proto = avio_find_protocol_name(filename);
5694     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5695 }
5696
5697 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5698 {
5699     AVDictionaryEntry *entry;
5700     int64_t parsed_timestamp;
5701     int ret;
5702     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5703         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5704             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5705             return 1;
5706         } else {
5707             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5708             return ret;
5709         }
5710     }
5711     return 0;
5712 }
5713
5714 int ff_standardize_creation_time(AVFormatContext *s)
5715 {
5716     int64_t timestamp;
5717     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5718     if (ret == 1)
5719         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5720     return ret;
5721 }
5722
5723 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5724 {
5725     uint8_t *side_data;
5726     int size;
5727
5728     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5729     if (side_data) {
5730         if (size != AVPALETTE_SIZE) {
5731             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5732             return AVERROR_INVALIDDATA;
5733         }
5734         memcpy(palette, side_data, AVPALETTE_SIZE);
5735         return 1;
5736     }
5737
5738     if (ret == CONTAINS_PAL) {
5739         int i;
5740         for (i = 0; i < AVPALETTE_COUNT; i++)
5741             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5742         return 1;
5743     }
5744
5745     return 0;
5746 }
5747
5748 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5749 {
5750     int ret;
5751     char *str;
5752
5753     ret = av_bprint_finalize(buf, &str);
5754     if (ret < 0)
5755         return ret;
5756     if (!av_bprint_is_complete(buf)) {
5757         av_free(str);
5758         return AVERROR(ENOMEM);
5759     }
5760
5761     par->extradata = str;
5762     /* Note: the string is NUL terminated (so extradata can be read as a
5763      * string), but the ending character is not accounted in the size (in
5764      * binary formats you are likely not supposed to mux that character). When
5765      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5766      * zeros. */
5767     par->extradata_size = buf->len;
5768     return 0;
5769 }
5770
5771 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5772                                                   AVStream *ost, const AVStream *ist,
5773                                                   enum AVTimebaseSource copy_tb)
5774 {
5775     //TODO: use [io]st->internal->avctx
5776     const AVCodecContext *dec_ctx = ist->codec;
5777     AVCodecContext       *enc_ctx = ost->codec;
5778
5779     enc_ctx->time_base = ist->time_base;
5780     /*
5781      * Avi is a special case here because it supports variable fps but
5782      * having the fps and timebase differe significantly adds quite some
5783      * overhead
5784      */
5785     if (!strcmp(ofmt->name, "avi")) {
5786 #if FF_API_R_FRAME_RATE
5787         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5788             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5789             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5790             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5791             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5792             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5793             enc_ctx->time_base.num = ist->r_frame_rate.den;
5794             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5795             enc_ctx->ticks_per_frame = 2;
5796         } else
5797 #endif
5798             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5799                    && av_q2d(ist->time_base) < 1.0/500
5800                    || copy_tb == AVFMT_TBCF_DECODER) {
5801             enc_ctx->time_base = dec_ctx->time_base;
5802             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5803             enc_ctx->time_base.den *= 2;
5804             enc_ctx->ticks_per_frame = 2;
5805         }
5806     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5807                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5808         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5809             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5810             && av_q2d(ist->time_base) < 1.0/500
5811             || copy_tb == AVFMT_TBCF_DECODER) {
5812             enc_ctx->time_base = dec_ctx->time_base;
5813             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5814         }
5815     }
5816
5817     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5818         && dec_ctx->time_base.num < dec_ctx->time_base.den
5819         && dec_ctx->time_base.num > 0
5820         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5821         enc_ctx->time_base = dec_ctx->time_base;
5822     }
5823
5824     if (ost->avg_frame_rate.num)
5825         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5826
5827     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5828               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5829
5830     return 0;
5831 }
5832
5833 AVRational av_stream_get_codec_timebase(const AVStream *st)
5834 {
5835     // See avformat_transfer_internal_stream_timing_info() TODO.
5836 #if FF_API_LAVF_AVCTX
5837 FF_DISABLE_DEPRECATION_WARNINGS
5838     return st->codec->time_base;
5839 FF_ENABLE_DEPRECATION_WARNINGS
5840 #else
5841     return st->internal->avctx->time_base;
5842 #endif
5843 }
5844
5845 void ff_format_set_url(AVFormatContext *s, char *url)
5846 {
5847     av_assert0(url);
5848     av_freep(&s->url);
5849     s->url = url;
5850 #if FF_API_FORMAT_FILENAME
5851 FF_DISABLE_DEPRECATION_WARNINGS
5852     av_strlcpy(s->filename, url, sizeof(s->filename));
5853 FF_ENABLE_DEPRECATION_WARNINGS
5854 #endif
5855 }