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 static int 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_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_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, int 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 = 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 || 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(8 * filesize, 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: %0.3f duration: %0.3f\n", i,
2988                        (double) st->start_time * av_q2d(st->time_base),
2989                        (double) st->duration   * av_q2d(st->time_base));
2990         }
2991         av_log(ic, AV_LOG_TRACE,
2992                 "format: start_time: %0.3f duration: %0.3f (estimate from %s) bitrate=%"PRId64" kb/s\n",
2993                 (double) ic->start_time / AV_TIME_BASE,
2994                 (double) ic->duration   / AV_TIME_BASE,
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' and 'probesize' options\n",
4136                    i, buf, errmsg);
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         for (i = 0; i < st->internal->nb_bsfcs; i++) {
4412             av_bsf_free(&st->internal->bsfcs[i]);
4413             av_freep(&st->internal->bsfcs);
4414         }
4415         av_freep(&st->internal->priv_pts);
4416         av_bsf_free(&st->internal->extract_extradata.bsf);
4417         av_packet_free(&st->internal->extract_extradata.pkt);
4418     }
4419     av_freep(&st->internal);
4420
4421     av_dict_free(&st->metadata);
4422     avcodec_parameters_free(&st->codecpar);
4423     av_freep(&st->probe_data.buf);
4424     av_freep(&st->index_entries);
4425 #if FF_API_LAVF_AVCTX
4426 FF_DISABLE_DEPRECATION_WARNINGS
4427     avcodec_free_context(&st->codec);
4428 FF_ENABLE_DEPRECATION_WARNINGS
4429 #endif
4430     av_freep(&st->priv_data);
4431     if (st->info)
4432         av_freep(&st->info->duration_error);
4433     av_freep(&st->info);
4434 #if FF_API_LAVF_FFSERVER
4435 FF_DISABLE_DEPRECATION_WARNINGS
4436     av_freep(&st->recommended_encoder_configuration);
4437 FF_ENABLE_DEPRECATION_WARNINGS
4438 #endif
4439
4440     av_freep(pst);
4441 }
4442
4443 void ff_free_stream(AVFormatContext *s, AVStream *st)
4444 {
4445     av_assert0(s->nb_streams>0);
4446     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
4447
4448     free_stream(&s->streams[ --s->nb_streams ]);
4449 }
4450
4451 void avformat_free_context(AVFormatContext *s)
4452 {
4453     int i;
4454
4455     if (!s)
4456         return;
4457
4458     if (s->oformat && s->oformat->deinit && s->internal->initialized)
4459         s->oformat->deinit(s);
4460
4461     av_opt_free(s);
4462     if (s->iformat && s->iformat->priv_class && s->priv_data)
4463         av_opt_free(s->priv_data);
4464     if (s->oformat && s->oformat->priv_class && s->priv_data)
4465         av_opt_free(s->priv_data);
4466
4467     for (i = 0; i < s->nb_streams; i++)
4468         free_stream(&s->streams[i]);
4469     s->nb_streams = 0;
4470
4471     for (i = 0; i < s->nb_programs; i++) {
4472         av_dict_free(&s->programs[i]->metadata);
4473         av_freep(&s->programs[i]->stream_index);
4474         av_freep(&s->programs[i]);
4475     }
4476     s->nb_programs = 0;
4477
4478     av_freep(&s->programs);
4479     av_freep(&s->priv_data);
4480     while (s->nb_chapters--) {
4481         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
4482         av_freep(&s->chapters[s->nb_chapters]);
4483     }
4484     av_freep(&s->chapters);
4485     av_dict_free(&s->metadata);
4486     av_dict_free(&s->internal->id3v2_meta);
4487     av_freep(&s->streams);
4488     flush_packet_queue(s);
4489     av_freep(&s->internal);
4490     av_freep(&s->url);
4491     av_free(s);
4492 }
4493
4494 void avformat_close_input(AVFormatContext **ps)
4495 {
4496     AVFormatContext *s;
4497     AVIOContext *pb;
4498
4499     if (!ps || !*ps)
4500         return;
4501
4502     s  = *ps;
4503     pb = s->pb;
4504
4505     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
4506         (s->flags & AVFMT_FLAG_CUSTOM_IO))
4507         pb = NULL;
4508
4509     flush_packet_queue(s);
4510
4511     if (s->iformat)
4512         if (s->iformat->read_close)
4513             s->iformat->read_close(s);
4514
4515     avformat_free_context(s);
4516
4517     *ps = NULL;
4518
4519     avio_close(pb);
4520 }
4521
4522 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
4523 {
4524     AVStream *st;
4525     int i;
4526     AVStream **streams;
4527
4528     if (s->nb_streams >= FFMIN(s->max_streams, INT_MAX/sizeof(*streams))) {
4529         if (s->max_streams < INT_MAX/sizeof(*streams))
4530             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);
4531         return NULL;
4532     }
4533     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
4534     if (!streams)
4535         return NULL;
4536     s->streams = streams;
4537
4538     st = av_mallocz(sizeof(AVStream));
4539     if (!st)
4540         return NULL;
4541     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
4542         av_free(st);
4543         return NULL;
4544     }
4545     st->info->last_dts = AV_NOPTS_VALUE;
4546
4547 #if FF_API_LAVF_AVCTX
4548 FF_DISABLE_DEPRECATION_WARNINGS
4549     st->codec = avcodec_alloc_context3(c);
4550     if (!st->codec) {
4551         av_free(st->info);
4552         av_free(st);
4553         return NULL;
4554     }
4555 FF_ENABLE_DEPRECATION_WARNINGS
4556 #endif
4557
4558     st->internal = av_mallocz(sizeof(*st->internal));
4559     if (!st->internal)
4560         goto fail;
4561
4562     st->codecpar = avcodec_parameters_alloc();
4563     if (!st->codecpar)
4564         goto fail;
4565
4566     st->internal->avctx = avcodec_alloc_context3(NULL);
4567     if (!st->internal->avctx)
4568         goto fail;
4569
4570     if (s->iformat) {
4571 #if FF_API_LAVF_AVCTX
4572 FF_DISABLE_DEPRECATION_WARNINGS
4573         /* no default bitrate if decoding */
4574         st->codec->bit_rate = 0;
4575 FF_ENABLE_DEPRECATION_WARNINGS
4576 #endif
4577
4578         /* default pts setting is MPEG-like */
4579         avpriv_set_pts_info(st, 33, 1, 90000);
4580         /* we set the current DTS to 0 so that formats without any timestamps
4581          * but durations get some timestamps, formats with some unknown
4582          * timestamps have their first few packets buffered and the
4583          * timestamps corrected before they are returned to the user */
4584         st->cur_dts = RELATIVE_TS_BASE;
4585     } else {
4586         st->cur_dts = AV_NOPTS_VALUE;
4587     }
4588
4589     st->index      = s->nb_streams;
4590     st->start_time = AV_NOPTS_VALUE;
4591     st->duration   = AV_NOPTS_VALUE;
4592     st->first_dts     = AV_NOPTS_VALUE;
4593     st->probe_packets = s->max_probe_packets;
4594     st->pts_wrap_reference = AV_NOPTS_VALUE;
4595     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4596
4597     st->last_IP_pts = AV_NOPTS_VALUE;
4598     st->last_dts_for_order_check = AV_NOPTS_VALUE;
4599     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
4600         st->pts_buffer[i] = AV_NOPTS_VALUE;
4601
4602     st->sample_aspect_ratio = (AVRational) { 0, 1 };
4603
4604 #if FF_API_R_FRAME_RATE
4605     st->info->last_dts      = AV_NOPTS_VALUE;
4606 #endif
4607     st->info->fps_first_dts = AV_NOPTS_VALUE;
4608     st->info->fps_last_dts  = AV_NOPTS_VALUE;
4609
4610     st->inject_global_side_data = s->internal->inject_global_side_data;
4611
4612     st->internal->need_context_update = 1;
4613
4614     s->streams[s->nb_streams++] = st;
4615     return st;
4616 fail:
4617     free_stream(&st);
4618     return NULL;
4619 }
4620
4621 AVProgram *av_new_program(AVFormatContext *ac, int id)
4622 {
4623     AVProgram *program = NULL;
4624     int i;
4625
4626     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
4627
4628     for (i = 0; i < ac->nb_programs; i++)
4629         if (ac->programs[i]->id == id)
4630             program = ac->programs[i];
4631
4632     if (!program) {
4633         program = av_mallocz(sizeof(AVProgram));
4634         if (!program)
4635             return NULL;
4636         dynarray_add(&ac->programs, &ac->nb_programs, program);
4637         program->discard = AVDISCARD_NONE;
4638         program->pmt_version = -1;
4639     }
4640     program->id = id;
4641     program->pts_wrap_reference = AV_NOPTS_VALUE;
4642     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
4643
4644     program->start_time =
4645     program->end_time   = AV_NOPTS_VALUE;
4646
4647     return program;
4648 }
4649
4650 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
4651                               int64_t start, int64_t end, const char *title)
4652 {
4653     AVChapter *chapter = NULL;
4654     int i;
4655
4656     if (end != AV_NOPTS_VALUE && start > end) {
4657         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
4658         return NULL;
4659     }
4660
4661     for (i = 0; i < s->nb_chapters; i++)
4662         if (s->chapters[i]->id == id)
4663             chapter = s->chapters[i];
4664
4665     if (!chapter) {
4666         chapter = av_mallocz(sizeof(AVChapter));
4667         if (!chapter)
4668             return NULL;
4669         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
4670     }
4671     av_dict_set(&chapter->metadata, "title", title, 0);
4672     chapter->id        = id;
4673     chapter->time_base = time_base;
4674     chapter->start     = start;
4675     chapter->end       = end;
4676
4677     return chapter;
4678 }
4679
4680 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
4681 {
4682     int i, j;
4683     AVProgram *program = NULL;
4684     void *tmp;
4685
4686     if (idx >= ac->nb_streams) {
4687         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
4688         return;
4689     }
4690
4691     for (i = 0; i < ac->nb_programs; i++) {
4692         if (ac->programs[i]->id != progid)
4693             continue;
4694         program = ac->programs[i];
4695         for (j = 0; j < program->nb_stream_indexes; j++)
4696             if (program->stream_index[j] == idx)
4697                 return;
4698
4699         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
4700         if (!tmp)
4701             return;
4702         program->stream_index = tmp;
4703         program->stream_index[program->nb_stream_indexes++] = idx;
4704         return;
4705     }
4706 }
4707
4708 uint64_t ff_ntp_time(void)
4709 {
4710     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
4711 }
4712
4713 uint64_t ff_get_formatted_ntp_time(uint64_t ntp_time_us)
4714 {
4715     uint64_t ntp_ts, frac_part, sec;
4716     uint32_t usec;
4717
4718     //current ntp time in seconds and micro seconds
4719     sec = ntp_time_us / 1000000;
4720     usec = ntp_time_us % 1000000;
4721
4722     //encoding in ntp timestamp format
4723     frac_part = usec * 0xFFFFFFFFULL;
4724     frac_part /= 1000000;
4725
4726     if (sec > 0xFFFFFFFFULL)
4727         av_log(NULL, AV_LOG_WARNING, "NTP time format roll over detected\n");
4728
4729     ntp_ts = sec << 32;
4730     ntp_ts |= frac_part;
4731
4732     return ntp_ts;
4733 }
4734
4735 int av_get_frame_filename2(char *buf, int buf_size, const char *path, int number, int flags)
4736 {
4737     const char *p;
4738     char *q, buf1[20], c;
4739     int nd, len, percentd_found;
4740
4741     q = buf;
4742     p = path;
4743     percentd_found = 0;
4744     for (;;) {
4745         c = *p++;
4746         if (c == '\0')
4747             break;
4748         if (c == '%') {
4749             do {
4750                 nd = 0;
4751                 while (av_isdigit(*p))
4752                     nd = nd * 10 + *p++ - '0';
4753                 c = *p++;
4754             } while (av_isdigit(c));
4755
4756             switch (c) {
4757             case '%':
4758                 goto addchar;
4759             case 'd':
4760                 if (!(flags & AV_FRAME_FILENAME_FLAGS_MULTIPLE) && percentd_found)
4761                     goto fail;
4762                 percentd_found = 1;
4763                 if (number < 0)
4764                     nd += 1;
4765                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
4766                 len = strlen(buf1);
4767                 if ((q - buf + len) > buf_size - 1)
4768                     goto fail;
4769                 memcpy(q, buf1, len);
4770                 q += len;
4771                 break;
4772             default:
4773                 goto fail;
4774             }
4775         } else {
4776 addchar:
4777             if ((q - buf) < buf_size - 1)
4778                 *q++ = c;
4779         }
4780     }
4781     if (!percentd_found)
4782         goto fail;
4783     *q = '\0';
4784     return 0;
4785 fail:
4786     *q = '\0';
4787     return -1;
4788 }
4789
4790 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
4791 {
4792     return av_get_frame_filename2(buf, buf_size, path, number, 0);
4793 }
4794
4795 void av_url_split(char *proto, int proto_size,
4796                   char *authorization, int authorization_size,
4797                   char *hostname, int hostname_size,
4798                   int *port_ptr, char *path, int path_size, const char *url)
4799 {
4800     const char *p, *ls, *at, *at2, *col, *brk;
4801
4802     if (port_ptr)
4803         *port_ptr = -1;
4804     if (proto_size > 0)
4805         proto[0] = 0;
4806     if (authorization_size > 0)
4807         authorization[0] = 0;
4808     if (hostname_size > 0)
4809         hostname[0] = 0;
4810     if (path_size > 0)
4811         path[0] = 0;
4812
4813     /* parse protocol */
4814     if ((p = strchr(url, ':'))) {
4815         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4816         p++; /* skip ':' */
4817         if (*p == '/')
4818             p++;
4819         if (*p == '/')
4820             p++;
4821     } else {
4822         /* no protocol means plain filename */
4823         av_strlcpy(path, url, path_size);
4824         return;
4825     }
4826
4827     /* separate path from hostname */
4828     ls = p + strcspn(p, "/?#");
4829     av_strlcpy(path, ls, path_size);
4830
4831     /* the rest is hostname, use that to parse auth/port */
4832     if (ls != p) {
4833         /* authorization (user[:pass]@hostname) */
4834         at2 = p;
4835         while ((at = strchr(p, '@')) && at < ls) {
4836             av_strlcpy(authorization, at2,
4837                        FFMIN(authorization_size, at + 1 - at2));
4838             p = at + 1; /* skip '@' */
4839         }
4840
4841         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4842             /* [host]:port */
4843             av_strlcpy(hostname, p + 1,
4844                        FFMIN(hostname_size, brk - p));
4845             if (brk[1] == ':' && port_ptr)
4846                 *port_ptr = atoi(brk + 2);
4847         } else if ((col = strchr(p, ':')) && col < ls) {
4848             av_strlcpy(hostname, p,
4849                        FFMIN(col + 1 - p, hostname_size));
4850             if (port_ptr)
4851                 *port_ptr = atoi(col + 1);
4852         } else
4853             av_strlcpy(hostname, p,
4854                        FFMIN(ls + 1 - p, hostname_size));
4855     }
4856 }
4857
4858 int ff_mkdir_p(const char *path)
4859 {
4860     int ret = 0;
4861     char *temp = av_strdup(path);
4862     char *pos = temp;
4863     char tmp_ch = '\0';
4864
4865     if (!path || !temp) {
4866         return -1;
4867     }
4868
4869     if (!av_strncasecmp(temp, "/", 1) || !av_strncasecmp(temp, "\\", 1)) {
4870         pos++;
4871     } else if (!av_strncasecmp(temp, "./", 2) || !av_strncasecmp(temp, ".\\", 2)) {
4872         pos += 2;
4873     }
4874
4875     for ( ; *pos != '\0'; ++pos) {
4876         if (*pos == '/' || *pos == '\\') {
4877             tmp_ch = *pos;
4878             *pos = '\0';
4879             ret = mkdir(temp, 0755);
4880             *pos = tmp_ch;
4881         }
4882     }
4883
4884     if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
4885         ret = mkdir(temp, 0755);
4886     }
4887
4888     av_free(temp);
4889     return ret;
4890 }
4891
4892 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4893 {
4894     int i;
4895     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4896                                            '4', '5', '6', '7',
4897                                            '8', '9', 'A', 'B',
4898                                            'C', 'D', 'E', 'F' };
4899     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4900                                            '4', '5', '6', '7',
4901                                            '8', '9', 'a', 'b',
4902                                            'c', 'd', 'e', 'f' };
4903     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4904
4905     for (i = 0; i < s; i++) {
4906         buff[i * 2]     = hex_table[src[i] >> 4];
4907         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4908     }
4909
4910     return buff;
4911 }
4912
4913 int ff_hex_to_data(uint8_t *data, const char *p)
4914 {
4915     int c, len, v;
4916
4917     len = 0;
4918     v   = 1;
4919     for (;;) {
4920         p += strspn(p, SPACE_CHARS);
4921         if (*p == '\0')
4922             break;
4923         c = av_toupper((unsigned char) *p++);
4924         if (c >= '0' && c <= '9')
4925             c = c - '0';
4926         else if (c >= 'A' && c <= 'F')
4927             c = c - 'A' + 10;
4928         else
4929             break;
4930         v = (v << 4) | c;
4931         if (v & 0x100) {
4932             if (data)
4933                 data[len] = v;
4934             len++;
4935             v = 1;
4936         }
4937     }
4938     return len;
4939 }
4940
4941 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4942                          unsigned int pts_num, unsigned int pts_den)
4943 {
4944     AVRational new_tb;
4945     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4946         if (new_tb.num != pts_num)
4947             av_log(NULL, AV_LOG_DEBUG,
4948                    "st:%d removing common factor %d from timebase\n",
4949                    s->index, pts_num / new_tb.num);
4950     } else
4951         av_log(NULL, AV_LOG_WARNING,
4952                "st:%d has too large timebase, reducing\n", s->index);
4953
4954     if (new_tb.num <= 0 || new_tb.den <= 0) {
4955         av_log(NULL, AV_LOG_ERROR,
4956                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4957                new_tb.num, new_tb.den,
4958                s->index);
4959         return;
4960     }
4961     s->time_base     = new_tb;
4962 #if FF_API_LAVF_AVCTX
4963 FF_DISABLE_DEPRECATION_WARNINGS
4964     s->codec->pkt_timebase = new_tb;
4965 FF_ENABLE_DEPRECATION_WARNINGS
4966 #endif
4967     s->internal->avctx->pkt_timebase = new_tb;
4968     s->pts_wrap_bits = pts_wrap_bits;
4969 }
4970
4971 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4972                         void *context)
4973 {
4974     const char *ptr = str;
4975
4976     /* Parse key=value pairs. */
4977     for (;;) {
4978         const char *key;
4979         char *dest = NULL, *dest_end;
4980         int key_len, dest_len = 0;
4981
4982         /* Skip whitespace and potential commas. */
4983         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4984             ptr++;
4985         if (!*ptr)
4986             break;
4987
4988         key = ptr;
4989
4990         if (!(ptr = strchr(key, '=')))
4991             break;
4992         ptr++;
4993         key_len = ptr - key;
4994
4995         callback_get_buf(context, key, key_len, &dest, &dest_len);
4996         dest_end = dest + dest_len - 1;
4997
4998         if (*ptr == '\"') {
4999             ptr++;
5000             while (*ptr && *ptr != '\"') {
5001                 if (*ptr == '\\') {
5002                     if (!ptr[1])
5003                         break;
5004                     if (dest && dest < dest_end)
5005                         *dest++ = ptr[1];
5006                     ptr += 2;
5007                 } else {
5008                     if (dest && dest < dest_end)
5009                         *dest++ = *ptr;
5010                     ptr++;
5011                 }
5012             }
5013             if (*ptr == '\"')
5014                 ptr++;
5015         } else {
5016             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
5017                 if (dest && dest < dest_end)
5018                     *dest++ = *ptr;
5019         }
5020         if (dest)
5021             *dest = 0;
5022     }
5023 }
5024
5025 int ff_find_stream_index(AVFormatContext *s, int id)
5026 {
5027     int i;
5028     for (i = 0; i < s->nb_streams; i++)
5029         if (s->streams[i]->id == id)
5030             return i;
5031     return -1;
5032 }
5033
5034 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
5035                          int std_compliance)
5036 {
5037     if (ofmt) {
5038         unsigned int codec_tag;
5039         if (ofmt->query_codec)
5040             return ofmt->query_codec(codec_id, std_compliance);
5041         else if (ofmt->codec_tag)
5042             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
5043         else if (codec_id == ofmt->video_codec ||
5044                  codec_id == ofmt->audio_codec ||
5045                  codec_id == ofmt->subtitle_codec ||
5046                  codec_id == ofmt->data_codec)
5047             return 1;
5048     }
5049     return AVERROR_PATCHWELCOME;
5050 }
5051
5052 int avformat_network_init(void)
5053 {
5054 #if CONFIG_NETWORK
5055     int ret;
5056     if ((ret = ff_network_init()) < 0)
5057         return ret;
5058     if ((ret = ff_tls_init()) < 0)
5059         return ret;
5060 #endif
5061     return 0;
5062 }
5063
5064 int avformat_network_deinit(void)
5065 {
5066 #if CONFIG_NETWORK
5067     ff_network_close();
5068     ff_tls_deinit();
5069 #endif
5070     return 0;
5071 }
5072
5073 int ff_add_param_change(AVPacket *pkt, int32_t channels,
5074                         uint64_t channel_layout, int32_t sample_rate,
5075                         int32_t width, int32_t height)
5076 {
5077     uint32_t flags = 0;
5078     int size = 4;
5079     uint8_t *data;
5080     if (!pkt)
5081         return AVERROR(EINVAL);
5082     if (channels) {
5083         size  += 4;
5084         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
5085     }
5086     if (channel_layout) {
5087         size  += 8;
5088         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
5089     }
5090     if (sample_rate) {
5091         size  += 4;
5092         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
5093     }
5094     if (width || height) {
5095         size  += 8;
5096         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
5097     }
5098     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
5099     if (!data)
5100         return AVERROR(ENOMEM);
5101     bytestream_put_le32(&data, flags);
5102     if (channels)
5103         bytestream_put_le32(&data, channels);
5104     if (channel_layout)
5105         bytestream_put_le64(&data, channel_layout);
5106     if (sample_rate)
5107         bytestream_put_le32(&data, sample_rate);
5108     if (width || height) {
5109         bytestream_put_le32(&data, width);
5110         bytestream_put_le32(&data, height);
5111     }
5112     return 0;
5113 }
5114
5115 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
5116 {
5117     AVRational undef = {0, 1};
5118     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
5119     AVRational codec_sample_aspect_ratio  = stream && stream->codecpar ? stream->codecpar->sample_aspect_ratio : undef;
5120     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
5121
5122     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
5123                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
5124     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
5125         stream_sample_aspect_ratio = undef;
5126
5127     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
5128                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
5129     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
5130         frame_sample_aspect_ratio = undef;
5131
5132     if (stream_sample_aspect_ratio.num)
5133         return stream_sample_aspect_ratio;
5134     else
5135         return frame_sample_aspect_ratio;
5136 }
5137
5138 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
5139 {
5140     AVRational fr = st->r_frame_rate;
5141     AVRational codec_fr = st->internal->avctx->framerate;
5142     AVRational   avg_fr = st->avg_frame_rate;
5143
5144     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
5145         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
5146         fr = avg_fr;
5147     }
5148
5149
5150     if (st->internal->avctx->ticks_per_frame > 1) {
5151         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
5152             (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))
5153             fr = codec_fr;
5154     }
5155
5156     return fr;
5157 }
5158
5159 /**
5160  * Matches a stream specifier (but ignores requested index).
5161  *
5162  * @param indexptr set to point to the requested stream index if there is one
5163  *
5164  * @return <0 on error
5165  *         0  if st is NOT a matching stream
5166  *         >0 if st is a matching stream
5167  */
5168 static int match_stream_specifier(AVFormatContext *s, AVStream *st,
5169                                   const char *spec, const char **indexptr, AVProgram **p)
5170 {
5171     int match = 1;                      /* Stores if the specifier matches so far. */
5172     while (*spec) {
5173         if (*spec <= '9' && *spec >= '0') { /* opt:index */
5174             if (indexptr)
5175                 *indexptr = spec;
5176             return match;
5177         } else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
5178                    *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
5179             enum AVMediaType type;
5180             int nopic = 0;
5181
5182             switch (*spec++) {
5183             case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
5184             case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
5185             case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
5186             case 'd': type = AVMEDIA_TYPE_DATA;       break;
5187             case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
5188             case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
5189             default:  av_assert0(0);
5190             }
5191             if (*spec && *spec++ != ':')         /* If we are not at the end, then another specifier must follow. */
5192                 return AVERROR(EINVAL);
5193
5194 #if FF_API_LAVF_AVCTX
5195 FF_DISABLE_DEPRECATION_WARNINGS
5196             if (type != st->codecpar->codec_type
5197                && (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN || st->codec->codec_type != type))
5198                 match = 0;
5199     FF_ENABLE_DEPRECATION_WARNINGS
5200 #else
5201             if (type != st->codecpar->codec_type)
5202                 match = 0;
5203 #endif
5204             if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
5205                 match = 0;
5206         } else if (*spec == 'p' && *(spec + 1) == ':') {
5207             int prog_id, i, j;
5208             int found = 0;
5209             char *endptr;
5210             spec += 2;
5211             prog_id = strtol(spec, &endptr, 0);
5212             /* Disallow empty id and make sure that if we are not at the end, then another specifier must follow. */
5213             if (spec == endptr || (*endptr && *endptr++ != ':'))
5214                 return AVERROR(EINVAL);
5215             spec = endptr;
5216             if (match) {
5217                 for (i = 0; i < s->nb_programs; i++) {
5218                     if (s->programs[i]->id != prog_id)
5219                         continue;
5220
5221                     for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) {
5222                         if (st->index == s->programs[i]->stream_index[j]) {
5223                             found = 1;
5224                             if (p)
5225                                 *p = s->programs[i];
5226                             i = s->nb_programs;
5227                             break;
5228                         }
5229                     }
5230                 }
5231             }
5232             if (!found)
5233                 match = 0;
5234         } else if (*spec == '#' ||
5235                    (*spec == 'i' && *(spec + 1) == ':')) {
5236             int stream_id;
5237             char *endptr;
5238             spec += 1 + (*spec == 'i');
5239             stream_id = strtol(spec, &endptr, 0);
5240             if (spec == endptr || *endptr)                /* Disallow empty id and make sure we are at the end. */
5241                 return AVERROR(EINVAL);
5242             return match && (stream_id == st->id);
5243         } else if (*spec == 'm' && *(spec + 1) == ':') {
5244             AVDictionaryEntry *tag;
5245             char *key, *val;
5246             int ret;
5247
5248             if (match) {
5249                spec += 2;
5250                val = strchr(spec, ':');
5251
5252                key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
5253                if (!key)
5254                    return AVERROR(ENOMEM);
5255
5256                tag = av_dict_get(st->metadata, key, NULL, 0);
5257                if (tag) {
5258                    if (!val || !strcmp(tag->value, val + 1))
5259                        ret = 1;
5260                    else
5261                        ret = 0;
5262                } else
5263                    ret = 0;
5264
5265                av_freep(&key);
5266             }
5267             return match && ret;
5268         } else if (*spec == 'u' && *(spec + 1) == '\0') {
5269             AVCodecParameters *par = st->codecpar;
5270 #if FF_API_LAVF_AVCTX
5271 FF_DISABLE_DEPRECATION_WARNINGS
5272             AVCodecContext *codec = st->codec;
5273 FF_ENABLE_DEPRECATION_WARNINGS
5274 #endif
5275             int val;
5276             switch (par->codec_type) {
5277             case AVMEDIA_TYPE_AUDIO:
5278                 val = par->sample_rate && par->channels;
5279 #if FF_API_LAVF_AVCTX
5280                 val = val || (codec->sample_rate && codec->channels);
5281 #endif
5282                 if (par->format == AV_SAMPLE_FMT_NONE
5283 #if FF_API_LAVF_AVCTX
5284                     && codec->sample_fmt == AV_SAMPLE_FMT_NONE
5285 #endif
5286                     )
5287                     return 0;
5288                 break;
5289             case AVMEDIA_TYPE_VIDEO:
5290                 val = par->width && par->height;
5291 #if FF_API_LAVF_AVCTX
5292                 val = val || (codec->width && codec->height);
5293 #endif
5294                 if (par->format == AV_PIX_FMT_NONE
5295 #if FF_API_LAVF_AVCTX
5296                     && codec->pix_fmt == AV_PIX_FMT_NONE
5297 #endif
5298                     )
5299                     return 0;
5300                 break;
5301             case AVMEDIA_TYPE_UNKNOWN:
5302                 val = 0;
5303                 break;
5304             default:
5305                 val = 1;
5306                 break;
5307             }
5308 #if FF_API_LAVF_AVCTX
5309             return match && ((par->codec_id != AV_CODEC_ID_NONE || codec->codec_id != AV_CODEC_ID_NONE) && val != 0);
5310 #else
5311             return match && (par->codec_id != AV_CODEC_ID_NONE && val != 0);
5312 #endif
5313         } else {
5314             return AVERROR(EINVAL);
5315         }
5316     }
5317
5318     return match;
5319 }
5320
5321
5322 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
5323                                     const char *spec)
5324 {
5325     int ret, index;
5326     char *endptr;
5327     const char *indexptr = NULL;
5328     AVProgram *p = NULL;
5329     int nb_streams;
5330
5331     ret = match_stream_specifier(s, st, spec, &indexptr, &p);
5332     if (ret < 0)
5333         goto error;
5334
5335     if (!indexptr)
5336         return ret;
5337
5338     index = strtol(indexptr, &endptr, 0);
5339     if (*endptr) {                  /* We can't have anything after the requested index. */
5340         ret = AVERROR(EINVAL);
5341         goto error;
5342     }
5343
5344     /* This is not really needed but saves us a loop for simple stream index specifiers. */
5345     if (spec == indexptr)
5346         return (index == st->index);
5347
5348     /* If we requested a matching stream index, we have to ensure st is that. */
5349     nb_streams = p ? p->nb_stream_indexes : s->nb_streams;
5350     for (int i = 0; i < nb_streams && index >= 0; i++) {
5351         AVStream *candidate = p ? s->streams[p->stream_index[i]] : s->streams[i];
5352         ret = match_stream_specifier(s, candidate, spec, NULL, NULL);
5353         if (ret < 0)
5354             goto error;
5355         if (ret > 0 && index-- == 0 && st == candidate)
5356             return 1;
5357     }
5358     return 0;
5359
5360 error:
5361     if (ret == AVERROR(EINVAL))
5362         av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
5363     return ret;
5364 }
5365
5366 int ff_generate_avci_extradata(AVStream *st)
5367 {
5368     static const uint8_t avci100_1080p_extradata[] = {
5369         // SPS
5370         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5371         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5372         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5373         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
5374         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
5375         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
5376         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
5377         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
5378         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
5379         // PPS
5380         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5381         0xd0
5382     };
5383     static const uint8_t avci100_1080i_extradata[] = {
5384         // SPS
5385         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5386         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
5387         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
5388         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
5389         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
5390         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
5391         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
5392         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
5393         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
5394         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
5395         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
5396         // PPS
5397         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
5398         0xd0
5399     };
5400     static const uint8_t avci50_1080p_extradata[] = {
5401         // SPS
5402         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5403         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5404         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5405         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5406         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5407         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
5408         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
5409         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
5410         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
5411         // PPS
5412         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5413         0x11
5414     };
5415     static const uint8_t avci50_1080i_extradata[] = {
5416         // SPS
5417         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
5418         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5419         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5420         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
5421         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
5422         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
5423         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
5424         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
5425         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
5426         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
5427         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
5428         // PPS
5429         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5430         0x11
5431     };
5432     static const uint8_t avci100_720p_extradata[] = {
5433         // SPS
5434         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
5435         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
5436         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
5437         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
5438         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
5439         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
5440         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
5441         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
5442         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
5443         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
5444         // PPS
5445         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
5446         0x11
5447     };
5448     static const uint8_t avci50_720p_extradata[] = {
5449         // SPS
5450         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
5451         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
5452         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
5453         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
5454         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
5455         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
5456         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
5457         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
5458         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
5459         // PPS
5460         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
5461         0x11
5462     };
5463
5464     const uint8_t *data = NULL;
5465     int ret, size       = 0;
5466
5467     if (st->codecpar->width == 1920) {
5468         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5469             data = avci100_1080p_extradata;
5470             size = sizeof(avci100_1080p_extradata);
5471         } else {
5472             data = avci100_1080i_extradata;
5473             size = sizeof(avci100_1080i_extradata);
5474         }
5475     } else if (st->codecpar->width == 1440) {
5476         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
5477             data = avci50_1080p_extradata;
5478             size = sizeof(avci50_1080p_extradata);
5479         } else {
5480             data = avci50_1080i_extradata;
5481             size = sizeof(avci50_1080i_extradata);
5482         }
5483     } else if (st->codecpar->width == 1280) {
5484         data = avci100_720p_extradata;
5485         size = sizeof(avci100_720p_extradata);
5486     } else if (st->codecpar->width == 960) {
5487         data = avci50_720p_extradata;
5488         size = sizeof(avci50_720p_extradata);
5489     }
5490
5491     if (!size)
5492         return 0;
5493
5494     if ((ret = ff_alloc_extradata(st->codecpar, size)) < 0)
5495         return ret;
5496     memcpy(st->codecpar->extradata, data, size);
5497
5498     return 0;
5499 }
5500
5501 uint8_t *av_stream_get_side_data(const AVStream *st,
5502                                  enum AVPacketSideDataType type, int *size)
5503 {
5504     int i;
5505
5506     for (i = 0; i < st->nb_side_data; i++) {
5507         if (st->side_data[i].type == type) {
5508             if (size)
5509                 *size = st->side_data[i].size;
5510             return st->side_data[i].data;
5511         }
5512     }
5513     return NULL;
5514 }
5515
5516 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
5517                             uint8_t *data, size_t size)
5518 {
5519     AVPacketSideData *sd, *tmp;
5520     int i;
5521
5522     for (i = 0; i < st->nb_side_data; i++) {
5523         sd = &st->side_data[i];
5524
5525         if (sd->type == type) {
5526             av_freep(&sd->data);
5527             sd->data = data;
5528             sd->size = size;
5529             return 0;
5530         }
5531     }
5532
5533     if ((unsigned)st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
5534         return AVERROR(ERANGE);
5535
5536     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
5537     if (!tmp) {
5538         return AVERROR(ENOMEM);
5539     }
5540
5541     st->side_data = tmp;
5542     st->nb_side_data++;
5543
5544     sd = &st->side_data[st->nb_side_data - 1];
5545     sd->type = type;
5546     sd->data = data;
5547     sd->size = size;
5548
5549     return 0;
5550 }
5551
5552 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
5553                                  int size)
5554 {
5555     int ret;
5556     uint8_t *data = av_malloc(size);
5557
5558     if (!data)
5559         return NULL;
5560
5561     ret = av_stream_add_side_data(st, type, data, size);
5562     if (ret < 0) {
5563         av_freep(&data);
5564         return NULL;
5565     }
5566
5567     return data;
5568 }
5569
5570 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
5571 {
5572     int ret;
5573     const AVBitStreamFilter *bsf;
5574     AVBSFContext *bsfc;
5575     AVCodecParameters *in_par;
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     if (st->internal->nb_bsfcs) {
5586         in_par = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->par_out;
5587         bsfc->time_base_in = st->internal->bsfcs[st->internal->nb_bsfcs - 1]->time_base_out;
5588     } else {
5589         in_par = st->codecpar;
5590         bsfc->time_base_in = st->time_base;
5591     }
5592
5593     if ((ret = avcodec_parameters_copy(bsfc->par_in, in_par)) < 0) {
5594         av_bsf_free(&bsfc);
5595         return ret;
5596     }
5597
5598     if (args && bsfc->filter->priv_class) {
5599         const AVOption *opt = av_opt_next(bsfc->priv_data, NULL);
5600         const char * shorthand[2] = {NULL};
5601
5602         if (opt)
5603             shorthand[0] = opt->name;
5604
5605         if ((ret = av_opt_set_from_string(bsfc->priv_data, args, shorthand, "=", ":")) < 0) {
5606             av_bsf_free(&bsfc);
5607             return ret;
5608         }
5609     }
5610
5611     if ((ret = av_bsf_init(bsfc)) < 0) {
5612         av_bsf_free(&bsfc);
5613         return ret;
5614     }
5615
5616     if ((ret = av_dynarray_add_nofree(&st->internal->bsfcs, &st->internal->nb_bsfcs, bsfc))) {
5617         av_bsf_free(&bsfc);
5618         return ret;
5619     }
5620
5621     av_log(NULL, AV_LOG_VERBOSE,
5622            "Automatically inserted bitstream filter '%s'; args='%s'\n",
5623            name, args ? args : "");
5624     return 1;
5625 }
5626
5627 #if FF_API_OLD_BSF
5628 FF_DISABLE_DEPRECATION_WARNINGS
5629 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
5630                                AVBitStreamFilterContext *bsfc)
5631 {
5632     int ret = 0;
5633     while (bsfc) {
5634         AVPacket new_pkt = *pkt;
5635         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
5636                                            &new_pkt.data, &new_pkt.size,
5637                                            pkt->data, pkt->size,
5638                                            pkt->flags & AV_PKT_FLAG_KEY);
5639         if (a == 0 && new_pkt.size == 0 && new_pkt.side_data_elems == 0) {
5640             av_packet_unref(pkt);
5641             memset(pkt, 0, sizeof(*pkt));
5642             return 0;
5643         }
5644         if(a == 0 && new_pkt.data != pkt->data) {
5645             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
5646             if (t) {
5647                 memcpy(t, new_pkt.data, new_pkt.size);
5648                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
5649                 new_pkt.data = t;
5650                 new_pkt.buf = NULL;
5651                 a = 1;
5652             } else {
5653                 a = AVERROR(ENOMEM);
5654             }
5655         }
5656         if (a > 0) {
5657             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
5658                                            av_buffer_default_free, NULL, 0);
5659             if (new_pkt.buf) {
5660                 pkt->side_data = NULL;
5661                 pkt->side_data_elems = 0;
5662                 av_packet_unref(pkt);
5663             } else {
5664                 av_freep(&new_pkt.data);
5665                 a = AVERROR(ENOMEM);
5666             }
5667         }
5668         if (a < 0) {
5669             av_log(codec, AV_LOG_ERROR,
5670                    "Failed to open bitstream filter %s for stream %d with codec %s",
5671                    bsfc->filter->name, pkt->stream_index,
5672                    codec->codec ? codec->codec->name : "copy");
5673             ret = a;
5674             break;
5675         }
5676         *pkt = new_pkt;
5677
5678         bsfc = bsfc->next;
5679     }
5680     return ret;
5681 }
5682 FF_ENABLE_DEPRECATION_WARNINGS
5683 #endif
5684
5685 int ff_format_output_open(AVFormatContext *s, const char *url, AVDictionary **options)
5686 {
5687     if (!s->oformat)
5688         return AVERROR(EINVAL);
5689
5690     if (!(s->oformat->flags & AVFMT_NOFILE))
5691         return s->io_open(s, &s->pb, url, AVIO_FLAG_WRITE, options);
5692     return 0;
5693 }
5694
5695 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
5696 {
5697     if (*pb)
5698         s->io_close(s, *pb);
5699     *pb = NULL;
5700 }
5701
5702 int ff_is_http_proto(char *filename) {
5703     const char *proto = avio_find_protocol_name(filename);
5704     return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
5705 }
5706
5707 int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)
5708 {
5709     AVDictionaryEntry *entry;
5710     int64_t parsed_timestamp;
5711     int ret;
5712     if ((entry = av_dict_get(s->metadata, "creation_time", NULL, 0))) {
5713         if ((ret = av_parse_time(&parsed_timestamp, entry->value, 0)) >= 0) {
5714             *timestamp = return_seconds ? parsed_timestamp / 1000000 : parsed_timestamp;
5715             return 1;
5716         } else {
5717             av_log(s, AV_LOG_WARNING, "Failed to parse creation_time %s\n", entry->value);
5718             return ret;
5719         }
5720     }
5721     return 0;
5722 }
5723
5724 int ff_standardize_creation_time(AVFormatContext *s)
5725 {
5726     int64_t timestamp;
5727     int ret = ff_parse_creation_time_metadata(s, &timestamp, 0);
5728     if (ret == 1)
5729         return avpriv_dict_set_timestamp(&s->metadata, "creation_time", timestamp);
5730     return ret;
5731 }
5732
5733 int ff_get_packet_palette(AVFormatContext *s, AVPacket *pkt, int ret, uint32_t *palette)
5734 {
5735     uint8_t *side_data;
5736     int size;
5737
5738     side_data = av_packet_get_side_data(pkt, AV_PKT_DATA_PALETTE, &size);
5739     if (side_data) {
5740         if (size != AVPALETTE_SIZE) {
5741             av_log(s, AV_LOG_ERROR, "Invalid palette side data\n");
5742             return AVERROR_INVALIDDATA;
5743         }
5744         memcpy(palette, side_data, AVPALETTE_SIZE);
5745         return 1;
5746     }
5747
5748     if (ret == CONTAINS_PAL) {
5749         int i;
5750         for (i = 0; i < AVPALETTE_COUNT; i++)
5751             palette[i] = AV_RL32(pkt->data + pkt->size - AVPALETTE_SIZE + i*4);
5752         return 1;
5753     }
5754
5755     return 0;
5756 }
5757
5758 int ff_bprint_to_codecpar_extradata(AVCodecParameters *par, struct AVBPrint *buf)
5759 {
5760     int ret;
5761     char *str;
5762
5763     ret = av_bprint_finalize(buf, &str);
5764     if (ret < 0)
5765         return ret;
5766     if (!av_bprint_is_complete(buf)) {
5767         av_free(str);
5768         return AVERROR(ENOMEM);
5769     }
5770
5771     par->extradata = str;
5772     /* Note: the string is NUL terminated (so extradata can be read as a
5773      * string), but the ending character is not accounted in the size (in
5774      * binary formats you are likely not supposed to mux that character). When
5775      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
5776      * zeros. */
5777     par->extradata_size = buf->len;
5778     return 0;
5779 }
5780
5781 int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt,
5782                                                   AVStream *ost, const AVStream *ist,
5783                                                   enum AVTimebaseSource copy_tb)
5784 {
5785     //TODO: use [io]st->internal->avctx
5786     const AVCodecContext *dec_ctx = ist->codec;
5787     AVCodecContext       *enc_ctx = ost->codec;
5788
5789     enc_ctx->time_base = ist->time_base;
5790     /*
5791      * Avi is a special case here because it supports variable fps but
5792      * having the fps and timebase differe significantly adds quite some
5793      * overhead
5794      */
5795     if (!strcmp(ofmt->name, "avi")) {
5796 #if FF_API_R_FRAME_RATE
5797         if (copy_tb == AVFMT_TBCF_AUTO && ist->r_frame_rate.num
5798             && av_q2d(ist->r_frame_rate) >= av_q2d(ist->avg_frame_rate)
5799             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(ist->time_base)
5800             && 0.5/av_q2d(ist->r_frame_rate) > av_q2d(dec_ctx->time_base)
5801             && av_q2d(ist->time_base) < 1.0/500 && av_q2d(dec_ctx->time_base) < 1.0/500
5802             || copy_tb == AVFMT_TBCF_R_FRAMERATE) {
5803             enc_ctx->time_base.num = ist->r_frame_rate.den;
5804             enc_ctx->time_base.den = 2*ist->r_frame_rate.num;
5805             enc_ctx->ticks_per_frame = 2;
5806         } else
5807 #endif
5808             if (copy_tb == AVFMT_TBCF_AUTO && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > 2*av_q2d(ist->time_base)
5809                    && av_q2d(ist->time_base) < 1.0/500
5810                    || copy_tb == AVFMT_TBCF_DECODER) {
5811             enc_ctx->time_base = dec_ctx->time_base;
5812             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5813             enc_ctx->time_base.den *= 2;
5814             enc_ctx->ticks_per_frame = 2;
5815         }
5816     } else if (!(ofmt->flags & AVFMT_VARIABLE_FPS)
5817                && !av_match_name(ofmt->name, "mov,mp4,3gp,3g2,psp,ipod,ismv,f4v")) {
5818         if (copy_tb == AVFMT_TBCF_AUTO && dec_ctx->time_base.den
5819             && av_q2d(dec_ctx->time_base)*dec_ctx->ticks_per_frame > av_q2d(ist->time_base)
5820             && av_q2d(ist->time_base) < 1.0/500
5821             || copy_tb == AVFMT_TBCF_DECODER) {
5822             enc_ctx->time_base = dec_ctx->time_base;
5823             enc_ctx->time_base.num *= dec_ctx->ticks_per_frame;
5824         }
5825     }
5826
5827     if ((enc_ctx->codec_tag == AV_RL32("tmcd") || ost->codecpar->codec_tag == AV_RL32("tmcd"))
5828         && dec_ctx->time_base.num < dec_ctx->time_base.den
5829         && dec_ctx->time_base.num > 0
5830         && 121LL*dec_ctx->time_base.num > dec_ctx->time_base.den) {
5831         enc_ctx->time_base = dec_ctx->time_base;
5832     }
5833
5834     if (ost->avg_frame_rate.num)
5835         enc_ctx->time_base = av_inv_q(ost->avg_frame_rate);
5836
5837     av_reduce(&enc_ctx->time_base.num, &enc_ctx->time_base.den,
5838               enc_ctx->time_base.num, enc_ctx->time_base.den, INT_MAX);
5839
5840     return 0;
5841 }
5842
5843 AVRational av_stream_get_codec_timebase(const AVStream *st)
5844 {
5845     // See avformat_transfer_internal_stream_timing_info() TODO.
5846 #if FF_API_LAVF_AVCTX
5847 FF_DISABLE_DEPRECATION_WARNINGS
5848     return st->codec->time_base;
5849 FF_ENABLE_DEPRECATION_WARNINGS
5850 #else
5851     return st->internal->avctx->time_base;
5852 #endif
5853 }
5854
5855 void ff_format_set_url(AVFormatContext *s, char *url)
5856 {
5857     av_assert0(url);
5858     av_freep(&s->url);
5859     s->url = url;
5860 #if FF_API_FORMAT_FILENAME
5861 FF_DISABLE_DEPRECATION_WARNINGS
5862     av_strlcpy(s->filename, url, sizeof(s->filename));
5863 FF_ENABLE_DEPRECATION_WARNINGS
5864 #endif
5865 }