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