git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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