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