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