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\n");
 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\n");
 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             av_packet_unref(&pkt);
2146             if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2147                 if (pkt.flags & AV_PKT_FLAG_KEY)
2148                     break;
2149                 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2150                     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);
2151                     break;
2152                 }
2153             }
2154         }
2155         index = av_index_search_timestamp(st, timestamp, flags);
2156     }
2157     if (index < 0)
2158         return -1;
2159
2160     ff_read_frame_flush(s);
2161     if (s->iformat->read_seek)
2162         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2163             return 0;
2164     ie = &st->index_entries[index];
2165     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2166         return ret;
2167     ff_update_cur_dts(s, st, ie->timestamp);
2168
2169     return 0;
2170 }
2171
2172 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2173                                int64_t timestamp, int flags)
2174 {
2175     int ret;
2176     AVStream *st;
2177
2178     if (flags & AVSEEK_FLAG_BYTE) {
2179         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2180             return -1;
2181         ff_read_frame_flush(s);
2182         return seek_frame_byte(s, stream_index, timestamp, flags);
2183     }
2184
2185     if (stream_index < 0) {
2186         stream_index = av_find_default_stream_index(s);
2187         if (stream_index < 0)
2188             return -1;
2189
2190         st = s->streams[stream_index];
2191         /* timestamp for default must be expressed in AV_TIME_BASE units */
2192         timestamp = av_rescale(timestamp, st->time_base.den,
2193                                AV_TIME_BASE * (int64_t) st->time_base.num);
2194     }
2195
2196     /* first, we try the format specific seek */
2197     if (s->iformat->read_seek) {
2198         ff_read_frame_flush(s);
2199         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2200     } else
2201         ret = -1;
2202     if (ret >= 0)
2203         return 0;
2204
2205     if (s->iformat->read_timestamp &&
2206         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2207         ff_read_frame_flush(s);
2208         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2209     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2210         ff_read_frame_flush(s);
2211         return seek_frame_generic(s, stream_index, timestamp, flags);
2212     } else
2213         return -1;
2214 }
2215
2216 int av_seek_frame(AVFormatContext *s, int stream_index,
2217                   int64_t timestamp, int flags)
2218 {
2219     int ret;
2220
2221     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2222         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2223         if ((flags & AVSEEK_FLAG_BACKWARD))
2224             max_ts = timestamp;
2225         else
2226             min_ts = timestamp;
2227         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2228                                   flags & ~AVSEEK_FLAG_BACKWARD);
2229     }
2230
2231     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2232
2233     if (ret >= 0)
2234         ret = avformat_queue_attached_pictures(s);
2235
2236     return ret;
2237 }
2238
2239 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2240                        int64_t ts, int64_t max_ts, int flags)
2241 {
2242     if (min_ts > ts || max_ts < ts)
2243         return -1;
2244     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2245         return AVERROR(EINVAL);
2246
2247     if (s->seek2any>0)
2248         flags |= AVSEEK_FLAG_ANY;
2249     flags &= ~AVSEEK_FLAG_BACKWARD;
2250
2251     if (s->iformat->read_seek2) {
2252         int ret;
2253         ff_read_frame_flush(s);
2254
2255         if (stream_index == -1 && s->nb_streams == 1) {
2256             AVRational time_base = s->streams[0]->time_base;
2257             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2258             min_ts = av_rescale_rnd(min_ts, time_base.den,
2259                                     time_base.num * (int64_t)AV_TIME_BASE,
2260                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2261             max_ts = av_rescale_rnd(max_ts, time_base.den,
2262                                     time_base.num * (int64_t)AV_TIME_BASE,
2263                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2264         }
2265
2266         ret = s->iformat->read_seek2(s, stream_index, min_ts,
2267                                      ts, max_ts, flags);
2268
2269         if (ret >= 0)
2270             ret = avformat_queue_attached_pictures(s);
2271         return ret;
2272     }
2273
2274     if (s->iformat->read_timestamp) {
2275         // try to seek via read_timestamp()
2276     }
2277
2278     // Fall back on old API if new is not implemented but old is.
2279     // Note the old API has somewhat different semantics.
2280     if (s->iformat->read_seek || 1) {
2281         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2282         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2283         if (ret<0 && ts != min_ts && max_ts != ts) {
2284             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2285             if (ret >= 0)
2286                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2287         }
2288         return ret;
2289     }
2290
2291     // try some generic seek like seek_frame_generic() but with new ts semantics
2292     return -1; //unreachable
2293 }
2294
2295 int avformat_flush(AVFormatContext *s)
2296 {
2297     ff_read_frame_flush(s);
2298     return 0;
2299 }
2300
2301 /*******************************************************/
2302
2303 /**
2304  * Return TRUE if the stream has accurate duration in any stream.
2305  *
2306  * @return TRUE if the stream has accurate duration for at least one component.
2307  */
2308 static int has_duration(AVFormatContext *ic)
2309 {
2310     int i;
2311     AVStream *st;
2312
2313     for (i = 0; i < ic->nb_streams; i++) {
2314         st = ic->streams[i];
2315         if (st->duration != AV_NOPTS_VALUE)
2316             return 1;
2317     }
2318     if (ic->duration != AV_NOPTS_VALUE)
2319         return 1;
2320     return 0;
2321 }
2322
2323 /**
2324  * Estimate the stream timings from the one of each components.
2325  *
2326  * Also computes the global bitrate if possible.
2327  */
2328 static void update_stream_timings(AVFormatContext *ic)
2329 {
2330     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2331     int64_t duration, duration1, filesize;
2332     int i;
2333     AVStream *st;
2334     AVProgram *p;
2335
2336     start_time = INT64_MAX;
2337     start_time_text = INT64_MAX;
2338     end_time   = INT64_MIN;
2339     duration   = INT64_MIN;
2340     for (i = 0; i < ic->nb_streams; i++) {
2341         st = ic->streams[i];
2342         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2343             start_time1 = av_rescale_q(st->start_time, st->time_base,
2344                                        AV_TIME_BASE_Q);
2345             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2346                 if (start_time1 < start_time_text)
2347                     start_time_text = start_time1;
2348             } else
2349                 start_time = FFMIN(start_time, start_time1);
2350             end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
2351                                          AV_TIME_BASE_Q,
2352                                          AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
2353             if (end_time1 != AV_NOPTS_VALUE) {
2354                 end_time1 += start_time1;
2355                 end_time = FFMAX(end_time, end_time1);
2356             }
2357             for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2358                 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2359                     p->start_time = start_time1;
2360                 if (p->end_time < end_time1)
2361                     p->end_time = end_time1;
2362             }
2363         }
2364         if (st->duration != AV_NOPTS_VALUE) {
2365             duration1 = av_rescale_q(st->duration, st->time_base,
2366                                      AV_TIME_BASE_Q);
2367             duration  = FFMAX(duration, duration1);
2368         }
2369     }
2370     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2371         start_time = start_time_text;
2372     else if (start_time > start_time_text)
2373         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2374
2375     if (start_time != INT64_MAX) {
2376         ic->start_time = start_time;
2377         if (end_time != INT64_MIN) {
2378             if (ic->nb_programs) {
2379                 for (i = 0; i < ic->nb_programs; i++) {
2380                     p = ic->programs[i];
2381                     if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2382                         duration = FFMAX(duration, p->end_time - p->start_time);
2383                 }
2384             } else
2385                 duration = FFMAX(duration, end_time - start_time);
2386         }
2387     }
2388     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2389         ic->duration = duration;
2390     }
2391     if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2392         /* compute the bitrate */
2393         double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2394                          (double) ic->duration;
2395         if (bitrate >= 0 && bitrate <= INT64_MAX)
2396             ic->bit_rate = bitrate;
2397     }
2398 }
2399
2400 static void fill_all_stream_timings(AVFormatContext *ic)
2401 {
2402     int i;
2403     AVStream *st;
2404
2405     update_stream_timings(ic);
2406     for (i = 0; i < ic->nb_streams; i++) {
2407         st = ic->streams[i];
2408         if (st->start_time == AV_NOPTS_VALUE) {
2409             if (ic->start_time != AV_NOPTS_VALUE)
2410                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2411                                               st->time_base);
2412             if (ic->duration != AV_NOPTS_VALUE)
2413                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2414                                             st->time_base);
2415         }
2416     }
2417 }
2418
2419 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2420 {
2421     int64_t filesize, duration;
2422     int i, show_warning = 0;
2423     AVStream *st;
2424
2425     /* if bit_rate is already set, we believe it */
2426     if (ic->bit_rate <= 0) {
2427         int bit_rate = 0;
2428         for (i = 0; i < ic->nb_streams; i++) {
2429             st = ic->streams[i];
2430             if (st->codec->bit_rate > 0) {
2431                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2432                     bit_rate = 0;
2433                     break;
2434                 }
2435                 bit_rate += st->codec->bit_rate;
2436             } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->codec_info_nb_frames > 1) {
2437                 // If we have a videostream with packets but without a bitrate
2438                 // then consider the sum not known
2439                 bit_rate = 0;
2440                 break;
2441             }
2442         }
2443         ic->bit_rate = bit_rate;
2444     }
2445
2446     /* if duration is already set, we believe it */
2447     if (ic->duration == AV_NOPTS_VALUE &&
2448         ic->bit_rate != 0) {
2449         filesize = ic->pb ? avio_size(ic->pb) : 0;
2450         if (filesize > ic->internal->data_offset) {
2451             filesize -= ic->internal->data_offset;
2452             for (i = 0; i < ic->nb_streams; i++) {
2453                 st      = ic->streams[i];
2454                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2455                     && st->duration == AV_NOPTS_VALUE) {
2456                     duration = av_rescale(8 * filesize, st->time_base.den,
2457                                           ic->bit_rate *
2458                                           (int64_t) st->time_base.num);
2459                     st->duration = duration;
2460                     show_warning = 1;
2461                 }
2462             }
2463         }
2464     }
2465     if (show_warning)
2466         av_log(ic, AV_LOG_WARNING,
2467                "Estimating duration from bitrate, this may be inaccurate\n");
2468 }
2469
2470 #define DURATION_MAX_READ_SIZE 250000LL
2471 #define DURATION_MAX_RETRY 6
2472
2473 /* only usable for MPEG-PS streams */
2474 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2475 {
2476     AVPacket pkt1, *pkt = &pkt1;
2477     AVStream *st;
2478     int num, den, read_size, i, ret;
2479     int found_duration = 0;
2480     int is_end;
2481     int64_t filesize, offset, duration;
2482     int retry = 0;
2483
2484     /* flush packet queue */
2485     flush_packet_queue(ic);
2486
2487     for (i = 0; i < ic->nb_streams; i++) {
2488         st = ic->streams[i];
2489         if (st->start_time == AV_NOPTS_VALUE &&
2490             st->first_dts == AV_NOPTS_VALUE &&
2491             st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2492             av_log(st->codec, AV_LOG_WARNING,
2493                    "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2494
2495         if (st->parser) {
2496             av_parser_close(st->parser);
2497             st->parser = NULL;
2498         }
2499     }
2500
2501     av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2502     /* estimate the end time (duration) */
2503     /* XXX: may need to support wrapping */
2504     filesize = ic->pb ? avio_size(ic->pb) : 0;
2505     do {
2506         is_end = found_duration;
2507         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2508         if (offset < 0)
2509             offset = 0;
2510
2511         avio_seek(ic->pb, offset, SEEK_SET);
2512         read_size = 0;
2513         for (;;) {
2514             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2515                 break;
2516
2517             do {
2518                 ret = ff_read_packet(ic, pkt);
2519             } while (ret == AVERROR(EAGAIN));
2520             if (ret != 0)
2521                 break;
2522             read_size += pkt->size;
2523             st         = ic->streams[pkt->stream_index];
2524             if (pkt->pts != AV_NOPTS_VALUE &&
2525                 (st->start_time != AV_NOPTS_VALUE ||
2526                  st->first_dts  != AV_NOPTS_VALUE)) {
2527                 if (pkt->duration == 0) {
2528                     ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2529                     if (den && num) {
2530                         pkt->duration = av_rescale_rnd(1,
2531                                            num * (int64_t) st->time_base.den,
2532                                            den * (int64_t) st->time_base.num,
2533                                            AV_ROUND_DOWN);
2534                     }
2535                 }
2536                 duration = pkt->pts + pkt->duration;
2537                 found_duration = 1;
2538                 if (st->start_time != AV_NOPTS_VALUE)
2539                     duration -= st->start_time;
2540                 else
2541                     duration -= st->first_dts;
2542                 if (duration > 0) {
2543                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2544                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2545                         st->duration = duration;
2546                     st->info->last_duration = duration;
2547                 }
2548             }
2549             av_packet_unref(pkt);
2550         }
2551
2552         /* check if all audio/video streams have valid duration */
2553         if (!is_end) {
2554             is_end = 1;
2555             for (i = 0; i < ic->nb_streams; i++) {
2556                 st = ic->streams[i];
2557                 switch (st->codec->codec_type) {
2558                     case AVMEDIA_TYPE_VIDEO:
2559                     case AVMEDIA_TYPE_AUDIO:
2560                         if (st->duration == AV_NOPTS_VALUE)
2561                             is_end = 0;
2562                 }
2563             }
2564         }
2565     } while (!is_end &&
2566              offset &&
2567              ++retry <= DURATION_MAX_RETRY);
2568
2569     av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2570
2571     /* warn about audio/video streams which duration could not be estimated */
2572     for (i = 0; i < ic->nb_streams; i++) {
2573         st = ic->streams[i];
2574         if (st->duration == AV_NOPTS_VALUE) {
2575             switch (st->codec->codec_type) {
2576             case AVMEDIA_TYPE_VIDEO:
2577             case AVMEDIA_TYPE_AUDIO:
2578                 if (st->start_time != AV_NOPTS_VALUE || st->first_dts  != AV_NOPTS_VALUE) {
2579                     av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2580                 } else
2581                     av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2582             }
2583         }
2584     }
2585     fill_all_stream_timings(ic);
2586
2587     avio_seek(ic->pb, old_offset, SEEK_SET);
2588     for (i = 0; i < ic->nb_streams; i++) {
2589         int j;
2590
2591         st              = ic->streams[i];
2592         st->cur_dts     = st->first_dts;
2593         st->last_IP_pts = AV_NOPTS_VALUE;
2594         st->last_dts_for_order_check = AV_NOPTS_VALUE;
2595         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2596             st->pts_buffer[j] = AV_NOPTS_VALUE;
2597     }
2598 }
2599
2600 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2601 {
2602     int64_t file_size;
2603
2604     /* get the file size, if possible */
2605     if (ic->iformat->flags & AVFMT_NOFILE) {
2606         file_size = 0;
2607     } else {
2608         file_size = avio_size(ic->pb);
2609         file_size = FFMAX(0, file_size);
2610     }
2611
2612     if ((!strcmp(ic->iformat->name, "mpeg") ||
2613          !strcmp(ic->iformat->name, "mpegts")) &&
2614         file_size && ic->pb->seekable) {
2615         /* get accurate estimate from the PTSes */
2616         estimate_timings_from_pts(ic, old_offset);
2617         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2618     } else if (has_duration(ic)) {
2619         /* at least one component has timings - we use them for all
2620          * the components */
2621         fill_all_stream_timings(ic);
2622         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2623     } else {
2624         /* less precise: use bitrate info */
2625         estimate_timings_from_bit_rate(ic);
2626         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2627     }
2628     update_stream_timings(ic);
2629
2630     {
2631         int i;
2632         AVStream av_unused *st;
2633         for (i = 0; i < ic->nb_streams; i++) {
2634             st = ic->streams[i];
2635             av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
2636                     (double) st->start_time / AV_TIME_BASE,
2637                     (double) st->duration   / AV_TIME_BASE);
2638         }
2639         av_log(ic, AV_LOG_TRACE,
2640                 "stream: start_time: %0.3f duration: %0.3f bitrate=%"PRId64" kb/s\n",
2641                 (double) ic->start_time / AV_TIME_BASE,
2642                 (double) ic->duration   / AV_TIME_BASE,
2643                 (int64_t)ic->bit_rate / 1000);
2644     }
2645 }
2646
2647 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2648 {
2649     AVCodecContext *avctx = st->codec;
2650
2651 #define FAIL(errmsg) do {                                         \
2652         if (errmsg_ptr)                                           \
2653             *errmsg_ptr = errmsg;                                 \
2654         return 0;                                                 \
2655     } while (0)
2656
2657     if (   avctx->codec_id == AV_CODEC_ID_NONE
2658         && avctx->codec_type != AVMEDIA_TYPE_DATA)
2659         FAIL("unknown codec");
2660     switch (avctx->codec_type) {
2661     case AVMEDIA_TYPE_AUDIO:
2662         if (!avctx->frame_size && determinable_frame_size(avctx))
2663             FAIL("unspecified frame size");
2664         if (st->info->found_decoder >= 0 &&
2665             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2666             FAIL("unspecified sample format");
2667         if (!avctx->sample_rate)
2668             FAIL("unspecified sample rate");
2669         if (!avctx->channels)
2670             FAIL("unspecified number of channels");
2671         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2672             FAIL("no decodable DTS frames");
2673         break;
2674     case AVMEDIA_TYPE_VIDEO:
2675         if (!avctx->width)
2676             FAIL("unspecified size");
2677         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2678             FAIL("unspecified pixel format");
2679         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2680             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2681                 FAIL("no frame in rv30/40 and no sar");
2682         break;
2683     case AVMEDIA_TYPE_SUBTITLE:
2684         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2685             FAIL("unspecified size");
2686         break;
2687     case AVMEDIA_TYPE_DATA:
2688         if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2689     }
2690
2691     return 1;
2692 }
2693
2694 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2695 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2696                             AVDictionary **options)
2697 {
2698     const AVCodec *codec;
2699     int got_picture = 1, ret = 0;
2700     AVFrame *frame = av_frame_alloc();
2701     AVSubtitle subtitle;
2702     AVPacket pkt = *avpkt;
2703     int do_skip_frame = 0;
2704     enum AVDiscard skip_frame;
2705
2706     if (!frame)
2707         return AVERROR(ENOMEM);
2708
2709     if (!avcodec_is_open(st->codec) &&
2710         st->info->found_decoder <= 0 &&
2711         (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2712         AVDictionary *thread_opt = NULL;
2713
2714         codec = find_decoder(s, st, st->codec->codec_id);
2715
2716         if (!codec) {
2717             st->info->found_decoder = -st->codec->codec_id;
2718             ret                     = -1;
2719             goto fail;
2720         }
2721
2722         /* Force thread count to 1 since the H.264 decoder will not extract
2723          * SPS and PPS to extradata during multi-threaded decoding. */
2724         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2725         if (s->codec_whitelist)
2726             av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2727         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2728         if (!options)
2729             av_dict_free(&thread_opt);
2730         if (ret < 0) {
2731             st->info->found_decoder = -st->codec->codec_id;
2732             goto fail;
2733         }
2734         st->info->found_decoder = 1;
2735     } else if (!st->info->found_decoder)
2736         st->info->found_decoder = 1;
2737
2738     if (st->info->found_decoder < 0) {
2739         ret = -1;
2740         goto fail;
2741     }
2742
2743     if (st->codec->codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM) {
2744         do_skip_frame = 1;
2745         skip_frame = st->codec->skip_frame;
2746         st->codec->skip_frame = AVDISCARD_ALL;
2747     }
2748
2749     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2750            ret >= 0 &&
2751            (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2752             (!st->codec_info_nb_frames &&
2753              (st->codec->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2754         got_picture = 0;
2755         switch (st->codec->codec_type) {
2756         case AVMEDIA_TYPE_VIDEO:
2757             ret = avcodec_decode_video2(st->codec, frame,
2758                                         &got_picture, &pkt);
2759             break;
2760         case AVMEDIA_TYPE_AUDIO:
2761             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2762             break;
2763         case AVMEDIA_TYPE_SUBTITLE:
2764             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2765                                            &got_picture, &pkt);
2766             ret = pkt.size;
2767             break;
2768         default:
2769             break;
2770         }
2771         if (ret >= 0) {
2772             if (got_picture)
2773                 st->nb_decoded_frames++;
2774             pkt.data += ret;
2775             pkt.size -= ret;
2776             ret       = got_picture;
2777         }
2778     }
2779
2780     if (!pkt.data && !got_picture)
2781         ret = -1;
2782
2783 fail:
2784     if (do_skip_frame) {
2785         st->codec->skip_frame = skip_frame;
2786     }
2787
2788     av_frame_free(&frame);
2789     return ret;
2790 }
2791
2792 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2793 {
2794     while (tags->id != AV_CODEC_ID_NONE) {
2795         if (tags->id == id)
2796             return tags->tag;
2797         tags++;
2798     }
2799     return 0;
2800 }
2801
2802 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2803 {
2804     int i;
2805     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2806         if (tag == tags[i].tag)
2807             return tags[i].id;
2808     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2809         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2810             return tags[i].id;
2811     return AV_CODEC_ID_NONE;
2812 }
2813
2814 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2815 {
2816     if (flt) {
2817         switch (bps) {
2818         case 32:
2819             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2820         case 64:
2821             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2822         default:
2823             return AV_CODEC_ID_NONE;
2824         }
2825     } else {
2826         bps  += 7;
2827         bps >>= 3;
2828         if (sflags & (1 << (bps - 1))) {
2829             switch (bps) {
2830             case 1:
2831                 return AV_CODEC_ID_PCM_S8;
2832             case 2:
2833                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2834             case 3:
2835                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2836             case 4:
2837                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2838             default:
2839                 return AV_CODEC_ID_NONE;
2840             }
2841         } else {
2842             switch (bps) {
2843             case 1:
2844                 return AV_CODEC_ID_PCM_U8;
2845             case 2:
2846                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2847             case 3:
2848                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2849             case 4:
2850                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2851             default:
2852                 return AV_CODEC_ID_NONE;
2853             }
2854         }
2855     }
2856 }
2857
2858 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2859 {
2860     unsigned int tag;
2861     if (!av_codec_get_tag2(tags, id, &tag))
2862         return 0;
2863     return tag;
2864 }
2865
2866 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2867                       unsigned int *tag)
2868 {
2869     int i;
2870     for (i = 0; tags && tags[i]; i++) {
2871         const AVCodecTag *codec_tags = tags[i];
2872         while (codec_tags->id != AV_CODEC_ID_NONE) {
2873             if (codec_tags->id == id) {
2874                 *tag = codec_tags->tag;
2875                 return 1;
2876             }
2877             codec_tags++;
2878         }
2879     }
2880     return 0;
2881 }
2882
2883 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2884 {
2885     int i;
2886     for (i = 0; tags && tags[i]; i++) {
2887         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2888         if (id != AV_CODEC_ID_NONE)
2889             return id;
2890     }
2891     return AV_CODEC_ID_NONE;
2892 }
2893
2894 static void compute_chapters_end(AVFormatContext *s)
2895 {
2896     unsigned int i, j;
2897     int64_t max_time = 0;
2898
2899     if (s->duration > 0)
2900         max_time = s->duration +
2901                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2902
2903     for (i = 0; i < s->nb_chapters; i++)
2904         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2905             AVChapter *ch = s->chapters[i];
2906             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2907                                                   ch->time_base)
2908                                    : INT64_MAX;
2909
2910             for (j = 0; j < s->nb_chapters; j++) {
2911                 AVChapter *ch1     = s->chapters[j];
2912                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2913                                                   ch->time_base);
2914                 if (j != i && next_start > ch->start && next_start < end)
2915                     end = next_start;
2916             }
2917             ch->end = (end == INT64_MAX) ? ch->start : end;
2918         }
2919 }
2920
2921 static int get_std_framerate(int i)
2922 {
2923     if (i < 30*12)
2924         return (i + 1) * 1001;
2925     i -= 30*12;
2926
2927     if (i < 7)
2928         return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2929
2930     i -= 7;
2931
2932     return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2933 }
2934
2935 /* Is the time base unreliable?
2936  * This is a heuristic to balance between quick acceptance of the values in
2937  * the headers vs. some extra checks.
2938  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2939  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2940  * And there are "variable" fps files this needs to detect as well. */
2941 static int tb_unreliable(AVCodecContext *c)
2942 {
2943     if (c->time_base.den >= 101LL * c->time_base.num ||
2944         c->time_base.den <    5LL * c->time_base.num ||
2945         // c->codec_tag == AV_RL32("DIVX") ||
2946         // c->codec_tag == AV_RL32("XVID") ||
2947         c->codec_tag == AV_RL32("mp4v") ||
2948         c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2949         c->codec_id == AV_CODEC_ID_GIF ||
2950         c->codec_id == AV_CODEC_ID_HEVC ||
2951         c->codec_id == AV_CODEC_ID_H264)
2952         return 1;
2953     return 0;
2954 }
2955
2956 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2957 {
2958     int ret;
2959
2960     if (size < 0 || size >= INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
2961         avctx->extradata = NULL;
2962         avctx->extradata_size = 0;
2963         return AVERROR(EINVAL);
2964     }
2965     avctx->extradata = av_malloc(size + AV_INPUT_BUFFER_PADDING_SIZE);
2966     if (avctx->extradata) {
2967         memset(avctx->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2968         avctx->extradata_size = size;
2969         ret = 0;
2970     } else {
2971         avctx->extradata_size = 0;
2972         ret = AVERROR(ENOMEM);
2973     }
2974     return ret;
2975 }
2976
2977 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2978 {
2979     int ret = ff_alloc_extradata(avctx, size);
2980     if (ret < 0)
2981         return ret;
2982     ret = avio_read(pb, avctx->extradata, size);
2983     if (ret != size) {
2984         av_freep(&avctx->extradata);
2985         avctx->extradata_size = 0;
2986         av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2987         return ret < 0 ? ret : AVERROR_INVALIDDATA;
2988     }
2989
2990     return ret;
2991 }
2992
2993 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2994 {
2995     int i, j;
2996     int64_t last = st->info->last_dts;
2997
2998     if (   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2999        && ts - (uint64_t)last < INT64_MAX) {
3000         double dts = (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
3001         int64_t duration = ts - last;
3002
3003         if (!st->info->duration_error)
3004             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
3005         if (!st->info->duration_error)
3006             return AVERROR(ENOMEM);
3007
3008 //         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3009 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
3010         for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3011             if (st->info->duration_error[0][1][i] < 1e10) {
3012                 int framerate = get_std_framerate(i);
3013                 double sdts = dts*framerate/(1001*12);
3014                 for (j= 0; j<2; j++) {
3015                     int64_t ticks = llrint(sdts+j*0.5);
3016                     double error= sdts - ticks + j*0.5;
3017                     st->info->duration_error[j][0][i] += error;
3018                     st->info->duration_error[j][1][i] += error*error;
3019                 }
3020             }
3021         }
3022         st->info->duration_count++;
3023         st->info->rfps_duration_sum += duration;
3024
3025         if (st->info->duration_count % 10 == 0) {
3026             int n = st->info->duration_count;
3027             for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3028                 if (st->info->duration_error[0][1][i] < 1e10) {
3029                     double a0     = st->info->duration_error[0][0][i] / n;
3030                     double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3031                     double a1     = st->info->duration_error[1][0][i] / n;
3032                     double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3033                     if (error0 > 0.04 && error1 > 0.04) {
3034                         st->info->duration_error[0][1][i] = 2e10;
3035                         st->info->duration_error[1][1][i] = 2e10;
3036                     }
3037                 }
3038             }
3039         }
3040
3041         // ignore the first 4 values, they might have some random jitter
3042         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3043             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3044     }
3045     if (ts != AV_NOPTS_VALUE)
3046         st->info->last_dts = ts;
3047
3048     return 0;
3049 }
3050
3051 void ff_rfps_calculate(AVFormatContext *ic)
3052 {
3053     int i, j;
3054
3055     for (i = 0; i < ic->nb_streams; i++) {
3056         AVStream *st = ic->streams[i];
3057
3058         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3059             continue;
3060         // the check for tb_unreliable() is not completely correct, since this is not about handling
3061         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3062         // ipmovie.c produces.
3063         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)
3064             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);
3065         if (st->info->duration_count>1 && !st->r_frame_rate.num
3066             && tb_unreliable(st->codec)) {
3067             int num = 0;
3068             double best_error= 0.01;
3069             AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3070
3071             for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3072                 int k;
3073
3074                 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3075                     continue;
3076                 if (!st->info->codec_info_duration && get_std_framerate(j) < 1001*12)
3077                     continue;
3078
3079                 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3080                     continue;
3081
3082                 for (k= 0; k<2; k++) {
3083                     int n = st->info->duration_count;
3084                     double a= st->info->duration_error[k][0][j] / n;
3085                     double error= st->info->duration_error[k][1][j]/n - a*a;
3086
3087                     if (error < best_error && best_error> 0.000000001) {
3088                         best_error= error;
3089                         num = get_std_framerate(j);
3090                     }
3091                     if (error < 0.02)
3092                         av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3093                 }
3094             }
3095             // do not increase frame rate by more than 1 % in order to match a standard rate.
3096             if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3097                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3098         }
3099         if (   !st->avg_frame_rate.num
3100             && st->r_frame_rate.num && st->info->rfps_duration_sum
3101             && st->info->codec_info_duration <= 0
3102             && st->info->duration_count > 2
3103             && 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
3104             ) {
3105             av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3106             st->avg_frame_rate = st->r_frame_rate;
3107         }
3108
3109         av_freep(&st->info->duration_error);
3110         st->info->last_dts = AV_NOPTS_VALUE;
3111         st->info->duration_count = 0;
3112         st->info->rfps_duration_sum = 0;
3113     }
3114 }
3115
3116 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3117 {
3118     int i, count, ret = 0, j;
3119     int64_t read_size;
3120     AVStream *st;
3121     AVPacket pkt1, *pkt;
3122     int64_t old_offset  = avio_tell(ic->pb);
3123     // new streams might appear, no options for those
3124     int orig_nb_streams = ic->nb_streams;
3125     int flush_codecs;
3126     int64_t max_analyze_duration = ic->max_analyze_duration;
3127     int64_t max_stream_analyze_duration;
3128     int64_t max_subtitle_analyze_duration;
3129     int64_t probesize = ic->probesize;
3130
3131     flush_codecs = probesize > 0;
3132
3133     av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3134
3135     max_stream_analyze_duration = max_analyze_duration;
3136     max_subtitle_analyze_duration = max_analyze_duration;
3137     if (!max_analyze_duration) {
3138         max_stream_analyze_duration =
3139         max_analyze_duration        = 5*AV_TIME_BASE;
3140         max_subtitle_analyze_duration = 30*AV_TIME_BASE;
3141         if (!strcmp(ic->iformat->name, "flv"))
3142             max_stream_analyze_duration = 90*AV_TIME_BASE;
3143     }
3144
3145     if (ic->pb)
3146         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3147                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3148
3149     for (i = 0; i < ic->nb_streams; i++) {
3150         const AVCodec *codec;
3151         AVDictionary *thread_opt = NULL;
3152         st = ic->streams[i];
3153
3154         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3155             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3156 /*            if (!st->time_base.num)
3157                 st->time_base = */
3158             if (!st->codec->time_base.num)
3159                 st->codec->time_base = st->time_base;
3160         }
3161         // only for the split stuff
3162         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && st->request_probe <= 0) {
3163             st->parser = av_parser_init(st->codec->codec_id);
3164             if (st->parser) {
3165                 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3166                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3167                 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3168                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3169                 }
3170             } else if (st->need_parsing) {
3171                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3172                        "%s, packets or times may be invalid.\n",
3173                        avcodec_get_name(st->codec->codec_id));
3174             }
3175         }
3176         codec = find_decoder(ic, st, st->codec->codec_id);
3177
3178         /* Force thread count to 1 since the H.264 decoder will not extract
3179          * SPS and PPS to extradata during multi-threaded decoding. */
3180         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3181
3182         if (ic->codec_whitelist)
3183             av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3184
3185         /* Ensure that subtitle_header is properly set. */
3186         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3187             && codec && !st->codec->codec) {
3188             if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3189                 av_log(ic, AV_LOG_WARNING,
3190                        "Failed to open codec in av_find_stream_info\n");
3191         }
3192
3193         // Try to just open decoders, in case this is enough to get parameters.
3194         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3195             if (codec && !st->codec->codec)
3196                 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3197                     av_log(ic, AV_LOG_WARNING,
3198                            "Failed to open codec in av_find_stream_info\n");
3199         }
3200         if (!options)
3201             av_dict_free(&thread_opt);
3202     }
3203
3204     for (i = 0; i < ic->nb_streams; i++) {
3205 #if FF_API_R_FRAME_RATE
3206         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3207 #endif
3208         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3209         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
3210     }
3211
3212     count     = 0;
3213     read_size = 0;
3214     for (;;) {
3215         int analyzed_all_streams;
3216         if (ff_check_interrupt(&ic->interrupt_callback)) {
3217             ret = AVERROR_EXIT;
3218             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3219             break;
3220         }
3221
3222         /* check if one codec still needs to be handled */
3223         for (i = 0; i < ic->nb_streams; i++) {
3224             int fps_analyze_framecount = 20;
3225
3226             st = ic->streams[i];
3227             if (!has_codec_parameters(st, NULL))
3228                 break;
3229             /* If the timebase is coarse (like the usual millisecond precision
3230              * of mkv), we need to analyze more frames to reliably arrive at
3231              * the correct fps. */
3232             if (av_q2d(st->time_base) > 0.0005)
3233                 fps_analyze_framecount *= 2;
3234             if (!tb_unreliable(st->codec))
3235                 fps_analyze_framecount = 0;
3236             if (ic->fps_probe_size >= 0)
3237                 fps_analyze_framecount = ic->fps_probe_size;
3238             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3239                 fps_analyze_framecount = 0;
3240             /* variable fps and no guess at the real fps */
3241             if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3242                 st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3243                 int count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
3244                     st->info->codec_info_duration_fields/2 :
3245                     st->info->duration_count;
3246                 if (count < fps_analyze_framecount)
3247                     break;
3248             }
3249             if (st->parser && st->parser->parser->split &&
3250                 !st->codec->extradata)
3251                 break;
3252             if (st->first_dts == AV_NOPTS_VALUE &&
3253                 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3254                 st->codec_info_nb_frames < ic->max_ts_probe &&
3255                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3256                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3257                 break;
3258         }
3259         analyzed_all_streams = 0;
3260         if (i == ic->nb_streams) {
3261             analyzed_all_streams = 1;
3262             /* NOTE: If the format has no header, then we need to read some
3263              * packets to get most of the streams, so we cannot stop here. */
3264             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3265                 /* If we found the info for all the codecs, we can stop. */
3266                 ret = count;
3267                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3268                 flush_codecs = 0;
3269                 break;
3270             }
3271         }
3272         /* We did not get all the codec info, but we read too much data. */
3273         if (read_size >= probesize) {
3274             ret = count;
3275             av_log(ic, AV_LOG_DEBUG,
3276                    "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3277             for (i = 0; i < ic->nb_streams; i++)
3278                 if (!ic->streams[i]->r_frame_rate.num &&
3279                     ic->streams[i]->info->duration_count <= 1 &&
3280                     ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3281                     strcmp(ic->iformat->name, "image2"))
3282                     av_log(ic, AV_LOG_WARNING,
3283                            "Stream #%d: not enough frames to estimate rate; "
3284                            "consider increasing probesize\n", i);
3285             break;
3286         }
3287
3288         /* NOTE: A new stream can be added there if no header in file
3289          * (AVFMTCTX_NOHEADER). */
3290         ret = read_frame_internal(ic, &pkt1);
3291         if (ret == AVERROR(EAGAIN))
3292             continue;
3293
3294         if (ret < 0) {
3295             /* EOF or error*/
3296             break;
3297         }
3298
3299         pkt = &pkt1;
3300
3301         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
3302             ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
3303                                 &ic->internal->packet_buffer_end, 0);
3304             if (ret < 0)
3305                 goto find_stream_info_err;
3306         }
3307
3308         st = ic->streams[pkt->stream_index];
3309         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3310             read_size += pkt->size;
3311
3312         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3313             /* check for non-increasing dts */
3314             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3315                 st->info->fps_last_dts >= pkt->dts) {
3316                 av_log(ic, AV_LOG_DEBUG,
3317                        "Non-increasing DTS in stream %d: packet %d with DTS "
3318                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3319                        st->index, st->info->fps_last_dts_idx,
3320                        st->info->fps_last_dts, st->codec_info_nb_frames,
3321                        pkt->dts);
3322                 st->info->fps_first_dts =
3323                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3324             }
3325             /* Check for a discontinuity in dts. If the difference in dts
3326              * is more than 1000 times the average packet duration in the
3327              * sequence, we treat it as a discontinuity. */
3328             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3329                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3330                 (pkt->dts - st->info->fps_last_dts) / 1000 >
3331                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
3332                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3333                 av_log(ic, AV_LOG_WARNING,
3334                        "DTS discontinuity in stream %d: packet %d with DTS "
3335                        "%"PRId64", packet %d with DTS %"PRId64"\n",
3336                        st->index, st->info->fps_last_dts_idx,
3337                        st->info->fps_last_dts, st->codec_info_nb_frames,
3338                        pkt->dts);
3339                 st->info->fps_first_dts =
3340                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
3341             }
3342
3343             /* update stored dts values */
3344             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3345                 st->info->fps_first_dts     = pkt->dts;
3346                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3347             }
3348             st->info->fps_last_dts     = pkt->dts;
3349             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3350         }
3351         if (st->codec_info_nb_frames>1) {
3352             int64_t t = 0;
3353             int64_t limit;
3354
3355             if (st->time_base.den > 0)
3356                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3357             if (st->avg_frame_rate.num > 0)
3358                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3359
3360             if (   t == 0
3361                 && st->codec_info_nb_frames>30
3362                 && st->info->fps_first_dts != AV_NOPTS_VALUE
3363                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
3364                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3365
3366             if (analyzed_all_streams)                                limit = max_analyze_duration;
3367             else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
3368             else                                                     limit = max_stream_analyze_duration;
3369
3370             if (t >= limit) {
3371                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
3372                        limit,
3373                        t, pkt->stream_index);
3374                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3375                     av_packet_unref(pkt);
3376                 break;
3377             }
3378             if (pkt->duration) {
3379                 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && pkt->pts >= st->start_time) {
3380                     st->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, st->info->codec_info_duration + pkt->duration);
3381                 } else
3382                     st->info->codec_info_duration += pkt->duration;
3383                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3384             }
3385         }
3386 #if FF_API_R_FRAME_RATE
3387         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3388             ff_rfps_add_frame(ic, st, pkt->dts);
3389 #endif
3390         if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3391             int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3392             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3393                 if (ff_alloc_extradata(st->codec, i))
3394                     return AVERROR(ENOMEM);
3395                 memcpy(st->codec->extradata, pkt->data,
3396                        st->codec->extradata_size);
3397             }
3398         }
3399
3400         /* If still no information, we try to open the codec and to
3401          * decompress the frame. We try to avoid that in most cases as
3402          * it takes longer and uses more memory. For MPEG-4, we need to
3403          * decompress for QuickTime.
3404          *
3405          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3406          * least one frame of codec data, this makes sure the codec initializes
3407          * the channel configuration and does not only trust the values from
3408          * the container. */
3409         try_decode_frame(ic, st, pkt,
3410                          (options && i < orig_nb_streams) ? &options[i] : NULL);
3411
3412         if (ic->flags & AVFMT_FLAG_NOBUFFER)
3413             av_packet_unref(pkt);
3414
3415         st->codec_info_nb_frames++;
3416         count++;
3417     }
3418
3419     if (flush_codecs) {
3420         AVPacket empty_pkt = { 0 };
3421         int err = 0;
3422         av_init_packet(&empty_pkt);
3423
3424         for (i = 0; i < ic->nb_streams; i++) {
3425
3426             st = ic->streams[i];
3427
3428             /* flush the decoders */
3429             if (st->info->found_decoder == 1) {
3430                 do {
3431                     err = try_decode_frame(ic, st, &empty_pkt,
3432                                             (options && i < orig_nb_streams)
3433                                             ? &options[i] : NULL);
3434                 } while (err > 0 && !has_codec_parameters(st, NULL));
3435
3436                 if (err < 0) {
3437                     av_log(ic, AV_LOG_INFO,
3438                         "decoding for stream %d failed\n", st->index);
3439                 }
3440             }
3441         }
3442     }
3443
3444     // close codecs which were opened in try_decode_frame()
3445     for (i = 0; i < ic->nb_streams; i++) {
3446         st = ic->streams[i];
3447         avcodec_close(st->codec);
3448     }
3449
3450     ff_rfps_calculate(ic);
3451
3452     for (i = 0; i < ic->nb_streams; i++) {
3453         st = ic->streams[i];
3454         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3455             if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3456                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3457                 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3458                     st->codec->codec_tag= tag;
3459             }
3460
3461             /* estimate average framerate if not set by demuxer */
3462             if (st->info->codec_info_duration_fields &&
3463                 !st->avg_frame_rate.num &&
3464                 st->info->codec_info_duration) {
3465                 int best_fps      = 0;
3466                 double best_error = 0.01;
3467
3468                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3469                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3470                     st->info->codec_info_duration        < 0)
3471                     continue;
3472                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3473                           st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3474                           st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3475
3476                 /* Round guessed framerate to a "standard" framerate if it's
3477                  * within 1% of the original estimate. */
3478                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3479                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3480                     double error       = fabs(av_q2d(st->avg_frame_rate) /
3481                                               av_q2d(std_fps) - 1);
3482
3483                     if (error < best_error) {
3484                         best_error = error;
3485                         best_fps   = std_fps.num;
3486                     }
3487                 }
3488                 if (best_fps)
3489                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3490                               best_fps, 12 * 1001, INT_MAX);
3491             }
3492
3493             if (!st->r_frame_rate.num) {
3494                 if (    st->codec->time_base.den * (int64_t) st->time_base.num
3495                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3496                     st->r_frame_rate.num = st->codec->time_base.den;
3497                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3498                 } else {
3499                     st->r_frame_rate.num = st->time_base.den;
3500                     st->r_frame_rate.den = st->time_base.num;
3501                 }
3502             }
3503             if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3504                 AVRational hw_ratio = { st->codec->height, st->codec->width };
3505                 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3506                                                    hw_ratio);
3507             }
3508         } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3509             if (!st->codec->bits_per_coded_sample)
3510                 st->codec->bits_per_coded_sample =
3511                     av_get_bits_per_sample(st->codec->codec_id);
3512             // set stream disposition based on audio service type
3513             switch (st->codec->audio_service_type) {
3514             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3515                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3516                 break;
3517             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3518                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3519                 break;
3520             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3521                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3522                 break;
3523             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3524                 st->disposition = AV_DISPOSITION_COMMENT;
3525                 break;
3526             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3527                 st->disposition = AV_DISPOSITION_KARAOKE;
3528                 break;
3529             }
3530         }
3531     }
3532
3533     if (probesize)
3534         estimate_timings(ic, old_offset);
3535
3536     av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3537
3538     if (ret >= 0 && ic->nb_streams)
3539         /* We could not have all the codec parameters before EOF. */
3540         ret = -1;
3541     for (i = 0; i < ic->nb_streams; i++) {
3542         const char *errmsg;
3543         st = ic->streams[i];
3544         if (!has_codec_parameters(st, &errmsg)) {
3545             char buf[256];
3546             avcodec_string(buf, sizeof(buf), st->codec, 0);
3547             av_log(ic, AV_LOG_WARNING,
3548                    "Could not find codec parameters for stream %d (%s): %s\n"
3549                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3550                    i, buf, errmsg);
3551         } else {
3552             ret = 0;
3553         }
3554     }
3555
3556     compute_chapters_end(ic);
3557
3558 find_stream_info_err:
3559     for (i = 0; i < ic->nb_streams; i++) {
3560         st = ic->streams[i];
3561         if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3562             ic->streams[i]->codec->thread_count = 0;
3563         if (st->info)
3564             av_freep(&st->info->duration_error);
3565         av_freep(&ic->streams[i]->info);
3566     }
3567     if (ic->pb)
3568         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3569                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3570     return ret;
3571 }
3572
3573 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3574 {
3575     int i, j;
3576
3577     for (i = 0; i < ic->nb_programs; i++) {
3578         if (ic->programs[i] == last) {
3579             last = NULL;
3580         } else {
3581             if (!last)
3582                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3583                     if (ic->programs[i]->stream_index[j] == s)
3584                         return ic->programs[i];
3585         }
3586     }
3587     return NULL;
3588 }
3589
3590 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3591                         int wanted_stream_nb, int related_stream,
3592                         AVCodec **decoder_ret, int flags)
3593 {
3594     int i, nb_streams = ic->nb_streams;
3595     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3596     unsigned *program = NULL;
3597     const AVCodec *decoder = NULL, *best_decoder = NULL;
3598
3599     if (related_stream >= 0 && wanted_stream_nb < 0) {
3600         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3601         if (p) {
3602             program    = p->stream_index;
3603             nb_streams = p->nb_stream_indexes;
3604         }
3605     }
3606     for (i = 0; i < nb_streams; i++) {
3607         int real_stream_index = program ? program[i] : i;
3608         AVStream *st          = ic->streams[real_stream_index];
3609         AVCodecContext *avctx = st->codec;
3610         if (avctx->codec_type != type)
3611             continue;
3612         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3613             continue;
3614         if (wanted_stream_nb != real_stream_index &&
3615             st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3616                                AV_DISPOSITION_VISUAL_IMPAIRED))
3617             continue;
3618         if (type == AVMEDIA_TYPE_AUDIO && !(avctx->channels && avctx->sample_rate))
3619             continue;
3620         if (decoder_ret) {
3621             decoder = find_decoder(ic, st, st->codec->codec_id);
3622             if (!decoder) {
3623                 if (ret < 0)
3624                     ret = AVERROR_DECODER_NOT_FOUND;
3625                 continue;
3626             }
3627         }
3628         count = st->codec_info_nb_frames;
3629         bitrate = avctx->bit_rate;
3630         if (!bitrate)
3631             bitrate = avctx->rc_max_rate;
3632         multiframe = FFMIN(5, count);
3633         if ((best_multiframe >  multiframe) ||
3634             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3635             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3636             continue;
3637         best_count   = count;
3638         best_bitrate = bitrate;
3639         best_multiframe = multiframe;
3640         ret          = real_stream_index;
3641         best_decoder = decoder;
3642         if (program && i == nb_streams - 1 && ret < 0) {
3643             program    = NULL;
3644             nb_streams = ic->nb_streams;
3645             /* no related stream found, try again with everything */
3646             i = 0;
3647         }
3648     }
3649     if (decoder_ret)
3650         *decoder_ret = (AVCodec*)best_decoder;
3651     return ret;
3652 }
3653
3654 /*******************************************************/
3655
3656 int av_read_play(AVFormatContext *s)
3657 {
3658     if (s->iformat->read_play)
3659         return s->iformat->read_play(s);
3660     if (s->pb)
3661         return avio_pause(s->pb, 0);
3662     return AVERROR(ENOSYS);
3663 }
3664
3665 int av_read_pause(AVFormatContext *s)
3666 {
3667     if (s->iformat->read_pause)
3668         return s->iformat->read_pause(s);
3669     if (s->pb)
3670         return avio_pause(s->pb, 1);
3671     return AVERROR(ENOSYS);
3672 }
3673
3674 static void free_stream(AVStream **pst)
3675 {
3676     AVStream *st = *pst;
3677     int i;
3678
3679     if (!st)
3680         return;
3681
3682     for (i = 0; i < st->nb_side_data; i++)
3683         av_freep(&st->side_data[i].data);
3684     av_freep(&st->side_data);
3685
3686     if (st->parser)
3687         av_parser_close(st->parser);
3688
3689     if (st->attached_pic.data)
3690         av_packet_unref(&st->attached_pic);
3691
3692     av_freep(&st->internal);
3693
3694     av_dict_free(&st->metadata);
3695     av_freep(&st->probe_data.buf);
3696     av_freep(&st->index_entries);
3697     av_freep(&st->codec->extradata);
3698     av_freep(&st->codec->subtitle_header);
3699     av_freep(&st->codec);
3700     av_freep(&st->priv_data);
3701     if (st->info)
3702         av_freep(&st->info->duration_error);
3703     av_freep(&st->info);
3704     av_freep(&st->recommended_encoder_configuration);
3705     av_freep(&st->priv_pts);
3706
3707     av_freep(pst);
3708 }
3709
3710 void ff_free_stream(AVFormatContext *s, AVStream *st)
3711 {
3712     av_assert0(s->nb_streams>0);
3713     av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3714
3715     free_stream(&s->streams[ --s->nb_streams ]);
3716 }
3717
3718 void avformat_free_context(AVFormatContext *s)
3719 {
3720     int i;
3721
3722     if (!s)
3723         return;
3724
3725     av_opt_free(s);
3726     if (s->iformat && s->iformat->priv_class && s->priv_data)
3727         av_opt_free(s->priv_data);
3728     if (s->oformat && s->oformat->priv_class && s->priv_data)
3729         av_opt_free(s->priv_data);
3730
3731     for (i = s->nb_streams - 1; i >= 0; i--)
3732         ff_free_stream(s, s->streams[i]);
3733
3734
3735     for (i = s->nb_programs - 1; i >= 0; i--) {
3736         av_dict_free(&s->programs[i]->metadata);
3737         av_freep(&s->programs[i]->stream_index);
3738         av_freep(&s->programs[i]);
3739     }
3740     av_freep(&s->programs);
3741     av_freep(&s->priv_data);
3742     while (s->nb_chapters--) {
3743         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3744         av_freep(&s->chapters[s->nb_chapters]);
3745     }
3746     av_freep(&s->chapters);
3747     av_dict_free(&s->metadata);
3748     av_freep(&s->streams);
3749     av_freep(&s->internal);
3750     flush_packet_queue(s);
3751     av_free(s);
3752 }
3753
3754 void avformat_close_input(AVFormatContext **ps)
3755 {
3756     AVFormatContext *s;
3757     AVIOContext *pb;
3758
3759     if (!ps || !*ps)
3760         return;
3761
3762     s  = *ps;
3763     pb = s->pb;
3764
3765     if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3766         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3767         pb = NULL;
3768
3769     flush_packet_queue(s);
3770
3771     if (s->iformat)
3772         if (s->iformat->read_close)
3773             s->iformat->read_close(s);
3774
3775     avformat_free_context(s);
3776
3777     *ps = NULL;
3778
3779     avio_close(pb);
3780 }
3781
3782 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3783 {
3784     AVStream *st;
3785     int i;
3786     AVStream **streams;
3787
3788     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3789         return NULL;
3790     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3791     if (!streams)
3792         return NULL;
3793     s->streams = streams;
3794
3795     st = av_mallocz(sizeof(AVStream));
3796     if (!st)
3797         return NULL;
3798     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3799         av_free(st);
3800         return NULL;
3801     }
3802     st->info->last_dts = AV_NOPTS_VALUE;
3803
3804     st->codec = avcodec_alloc_context3(c);
3805     if (!st->codec) {
3806         av_free(st->info);
3807         av_free(st);
3808         return NULL;
3809     }
3810
3811     st->internal = av_mallocz(sizeof(*st->internal));
3812     if (!st->internal)
3813         goto fail;
3814
3815     if (s->iformat) {
3816         /* no default bitrate if decoding */
3817         st->codec->bit_rate = 0;
3818
3819         /* default pts setting is MPEG-like */
3820         avpriv_set_pts_info(st, 33, 1, 90000);
3821         /* we set the current DTS to 0 so that formats without any timestamps
3822          * but durations get some timestamps, formats with some unknown
3823          * timestamps have their first few packets buffered and the
3824          * timestamps corrected before they are returned to the user */
3825         st->cur_dts = RELATIVE_TS_BASE;
3826     } else {
3827         st->cur_dts = AV_NOPTS_VALUE;
3828     }
3829
3830     st->index      = s->nb_streams;
3831     st->start_time = AV_NOPTS_VALUE;
3832     st->duration   = AV_NOPTS_VALUE;
3833     st->first_dts     = AV_NOPTS_VALUE;
3834     st->probe_packets = MAX_PROBE_PACKETS;
3835     st->pts_wrap_reference = AV_NOPTS_VALUE;
3836     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3837
3838     st->last_IP_pts = AV_NOPTS_VALUE;
3839     st->last_dts_for_order_check = AV_NOPTS_VALUE;
3840     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3841         st->pts_buffer[i] = AV_NOPTS_VALUE;
3842
3843     st->sample_aspect_ratio = (AVRational) { 0, 1 };
3844
3845 #if FF_API_R_FRAME_RATE
3846     st->info->last_dts      = AV_NOPTS_VALUE;
3847 #endif
3848     st->info->fps_first_dts = AV_NOPTS_VALUE;
3849     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3850
3851     st->inject_global_side_data = s->internal->inject_global_side_data;
3852
3853     s->streams[s->nb_streams++] = st;
3854     return st;
3855 fail:
3856     free_stream(&st);
3857     return NULL;
3858 }
3859
3860 AVProgram *av_new_program(AVFormatContext *ac, int id)
3861 {
3862     AVProgram *program = NULL;
3863     int i;
3864
3865     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
3866
3867     for (i = 0; i < ac->nb_programs; i++)
3868         if (ac->programs[i]->id == id)
3869             program = ac->programs[i];
3870
3871     if (!program) {
3872         program = av_mallocz(sizeof(AVProgram));
3873         if (!program)
3874             return NULL;
3875         dynarray_add(&ac->programs, &ac->nb_programs, program);
3876         program->discard = AVDISCARD_NONE;
3877     }
3878     program->id = id;
3879     program->pts_wrap_reference = AV_NOPTS_VALUE;
3880     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3881
3882     program->start_time =
3883     program->end_time   = AV_NOPTS_VALUE;
3884
3885     return program;
3886 }
3887
3888 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3889                               int64_t start, int64_t end, const char *title)
3890 {
3891     AVChapter *chapter = NULL;
3892     int i;
3893
3894     if (end != AV_NOPTS_VALUE && start > end) {
3895         av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3896         return NULL;
3897     }
3898
3899     for (i = 0; i < s->nb_chapters; i++)
3900         if (s->chapters[i]->id == id)
3901             chapter = s->chapters[i];
3902
3903     if (!chapter) {
3904         chapter = av_mallocz(sizeof(AVChapter));
3905         if (!chapter)
3906             return NULL;
3907         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3908     }
3909     av_dict_set(&chapter->metadata, "title", title, 0);
3910     chapter->id        = id;
3911     chapter->time_base = time_base;
3912     chapter->start     = start;
3913     chapter->end       = end;
3914
3915     return chapter;
3916 }
3917
3918 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3919 {
3920     int i, j;
3921     AVProgram *program = NULL;
3922     void *tmp;
3923
3924     if (idx >= ac->nb_streams) {
3925         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3926         return;
3927     }
3928
3929     for (i = 0; i < ac->nb_programs; i++) {
3930         if (ac->programs[i]->id != progid)
3931             continue;
3932         program = ac->programs[i];
3933         for (j = 0; j < program->nb_stream_indexes; j++)
3934             if (program->stream_index[j] == idx)
3935                 return;
3936
3937         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3938         if (!tmp)
3939             return;
3940         program->stream_index = tmp;
3941         program->stream_index[program->nb_stream_indexes++] = idx;
3942         return;
3943     }
3944 }
3945
3946 uint64_t ff_ntp_time(void)
3947 {
3948     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3949 }
3950
3951 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3952 {
3953     const char *p;
3954     char *q, buf1[20], c;
3955     int nd, len, percentd_found;
3956
3957     q = buf;
3958     p = path;
3959     percentd_found = 0;
3960     for (;;) {
3961         c = *p++;
3962         if (c == '\0')
3963             break;
3964         if (c == '%') {
3965             do {
3966                 nd = 0;
3967                 while (av_isdigit(*p))
3968                     nd = nd * 10 + *p++ - '0';
3969                 c = *p++;
3970             } while (av_isdigit(c));
3971
3972             switch (c) {
3973             case '%':
3974                 goto addchar;
3975             case 'd':
3976                 if (percentd_found)
3977                     goto fail;
3978                 percentd_found = 1;
3979                 if (number < 0)
3980                     nd += 1;
3981                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3982                 len = strlen(buf1);
3983                 if ((q - buf + len) > buf_size - 1)
3984                     goto fail;
3985                 memcpy(q, buf1, len);
3986                 q += len;
3987                 break;
3988             default:
3989                 goto fail;
3990             }
3991         } else {
3992 addchar:
3993             if ((q - buf) < buf_size - 1)
3994                 *q++ = c;
3995         }
3996     }
3997     if (!percentd_found)
3998         goto fail;
3999     *q = '\0';
4000     return 0;
4001 fail:
4002     *q = '\0';
4003     return -1;
4004 }
4005
4006 void av_url_split(char *proto, int proto_size,
4007                   char *authorization, int authorization_size,
4008                   char *hostname, int hostname_size,
4009                   int *port_ptr, char *path, int path_size, const char *url)
4010 {
4011     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
4012
4013     if (port_ptr)
4014         *port_ptr = -1;
4015     if (proto_size > 0)
4016         proto[0] = 0;
4017     if (authorization_size > 0)
4018         authorization[0] = 0;
4019     if (hostname_size > 0)
4020         hostname[0] = 0;
4021     if (path_size > 0)
4022         path[0] = 0;
4023
4024     /* parse protocol */
4025     if ((p = strchr(url, ':'))) {
4026         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4027         p++; /* skip ':' */
4028         if (*p == '/')
4029             p++;
4030         if (*p == '/')
4031             p++;
4032     } else {
4033         /* no protocol means plain filename */
4034         av_strlcpy(path, url, path_size);
4035         return;
4036     }
4037
4038     /* separate path from hostname */
4039     ls = strchr(p, '/');
4040     ls2 = strchr(p, '?');
4041     if (!ls)
4042         ls = ls2;
4043     else if (ls && ls2)
4044         ls = FFMIN(ls, ls2);
4045     if (ls)
4046         av_strlcpy(path, ls, path_size);
4047     else
4048         ls = &p[strlen(p)];  // XXX
4049
4050     /* the rest is hostname, use that to parse auth/port */
4051     if (ls != p) {
4052         /* authorization (user[:pass]@hostname) */
4053         at2 = p;
4054         while ((at = strchr(p, '@')) && at < ls) {
4055             av_strlcpy(authorization, at2,
4056                        FFMIN(authorization_size, at + 1 - at2));
4057             p = at + 1; /* skip '@' */
4058         }
4059
4060         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4061             /* [host]:port */
4062             av_strlcpy(hostname, p + 1,
4063                        FFMIN(hostname_size, brk - p));
4064             if (brk[1] == ':' && port_ptr)
4065                 *port_ptr = atoi(brk + 2);
4066         } else if ((col = strchr(p, ':')) && col < ls) {
4067             av_strlcpy(hostname, p,
4068                        FFMIN(col + 1 - p, hostname_size));
4069             if (port_ptr)
4070                 *port_ptr = atoi(col + 1);
4071         } else
4072             av_strlcpy(hostname, p,
4073                        FFMIN(ls + 1 - p, hostname_size));
4074     }
4075 }
4076
4077 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4078 {
4079     int i;
4080     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4081                                            '4', '5', '6', '7',
4082                                            '8', '9', 'A', 'B',
4083                                            'C', 'D', 'E', 'F' };
4084     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4085                                            '4', '5', '6', '7',
4086                                            '8', '9', 'a', 'b',
4087                                            'c', 'd', 'e', 'f' };
4088     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4089
4090     for (i = 0; i < s; i++) {
4091         buff[i * 2]     = hex_table[src[i] >> 4];
4092         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4093     }
4094
4095     return buff;
4096 }
4097
4098 int ff_hex_to_data(uint8_t *data, const char *p)
4099 {
4100     int c, len, v;
4101
4102     len = 0;
4103     v   = 1;
4104     for (;;) {
4105         p += strspn(p, SPACE_CHARS);
4106         if (*p == '\0')
4107             break;
4108         c = av_toupper((unsigned char) *p++);
4109         if (c >= '0' && c <= '9')
4110             c = c - '0';
4111         else if (c >= 'A' && c <= 'F')
4112             c = c - 'A' + 10;
4113         else
4114             break;
4115         v = (v << 4) | c;
4116         if (v & 0x100) {
4117             if (data)
4118                 data[len] = v;
4119             len++;
4120             v = 1;
4121         }
4122     }
4123     return len;
4124 }
4125
4126 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4127                          unsigned int pts_num, unsigned int pts_den)
4128 {
4129     AVRational new_tb;
4130     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4131         if (new_tb.num != pts_num)
4132             av_log(NULL, AV_LOG_DEBUG,
4133                    "st:%d removing common factor %d from timebase\n",
4134                    s->index, pts_num / new_tb.num);
4135     } else
4136         av_log(NULL, AV_LOG_WARNING,
4137                "st:%d has too large timebase, reducing\n", s->index);
4138
4139     if (new_tb.num <= 0 || new_tb.den <= 0) {
4140         av_log(NULL, AV_LOG_ERROR,
4141                "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4142                new_tb.num, new_tb.den,
4143                s->index);
4144         return;
4145     }
4146     s->time_base     = new_tb;
4147     av_codec_set_pkt_timebase(s->codec, new_tb);
4148     s->pts_wrap_bits = pts_wrap_bits;
4149 }
4150
4151 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4152                         void *context)
4153 {
4154     const char *ptr = str;
4155
4156     /* Parse key=value pairs. */
4157     for (;;) {
4158         const char *key;
4159         char *dest = NULL, *dest_end;
4160         int key_len, dest_len = 0;
4161
4162         /* Skip whitespace and potential commas. */
4163         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4164             ptr++;
4165         if (!*ptr)
4166             break;
4167
4168         key = ptr;
4169
4170         if (!(ptr = strchr(key, '=')))
4171             break;
4172         ptr++;
4173         key_len = ptr - key;
4174
4175         callback_get_buf(context, key, key_len, &dest, &dest_len);
4176         dest_end = dest + dest_len - 1;
4177
4178         if (*ptr == '\"') {
4179             ptr++;
4180             while (*ptr && *ptr != '\"') {
4181                 if (*ptr == '\\') {
4182                     if (!ptr[1])
4183                         break;
4184                     if (dest && dest < dest_end)
4185                         *dest++ = ptr[1];
4186                     ptr += 2;
4187                 } else {
4188                     if (dest && dest < dest_end)
4189                         *dest++ = *ptr;
4190                     ptr++;
4191                 }
4192             }
4193             if (*ptr == '\"')
4194                 ptr++;
4195         } else {
4196             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4197                 if (dest && dest < dest_end)
4198                     *dest++ = *ptr;
4199         }
4200         if (dest)
4201             *dest = 0;
4202     }
4203 }
4204
4205 int ff_find_stream_index(AVFormatContext *s, int id)
4206 {
4207     int i;
4208     for (i = 0; i < s->nb_streams; i++)
4209         if (s->streams[i]->id == id)
4210             return i;
4211     return -1;
4212 }
4213
4214 int64_t ff_iso8601_to_unix_time(const char *datestr)
4215 {
4216     struct tm time1 = { 0 }, time2 = { 0 };
4217     const char *ret1, *ret2;
4218     ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
4219     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
4220     if (ret2 && !ret1)
4221         return av_timegm(&time2);
4222     else
4223         return av_timegm(&time1);
4224 }
4225
4226 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4227                          int std_compliance)
4228 {
4229     if (ofmt) {
4230         unsigned int codec_tag;
4231         if (ofmt->query_codec)
4232             return ofmt->query_codec(codec_id, std_compliance);
4233         else if (ofmt->codec_tag)
4234             return !!av_codec_get_tag2(ofmt->codec_tag, codec_id, &codec_tag);
4235         else if (codec_id == ofmt->video_codec ||
4236                  codec_id == ofmt->audio_codec ||
4237                  codec_id == ofmt->subtitle_codec)
4238             return 1;
4239     }
4240     return AVERROR_PATCHWELCOME;
4241 }
4242
4243 int avformat_network_init(void)
4244 {
4245 #if CONFIG_NETWORK
4246     int ret;
4247     ff_network_inited_globally = 1;
4248     if ((ret = ff_network_init()) < 0)
4249         return ret;
4250     if ((ret = ff_tls_init()) < 0)
4251         return ret;
4252 #endif
4253     return 0;
4254 }
4255
4256 int avformat_network_deinit(void)
4257 {
4258 #if CONFIG_NETWORK
4259     ff_network_close();
4260     ff_tls_deinit();
4261     ff_network_inited_globally = 0;
4262 #endif
4263     return 0;
4264 }
4265
4266 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4267                         uint64_t channel_layout, int32_t sample_rate,
4268                         int32_t width, int32_t height)
4269 {
4270     uint32_t flags = 0;
4271     int size = 4;
4272     uint8_t *data;
4273     if (!pkt)
4274         return AVERROR(EINVAL);
4275     if (channels) {
4276         size  += 4;
4277         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4278     }
4279     if (channel_layout) {
4280         size  += 8;
4281         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4282     }
4283     if (sample_rate) {
4284         size  += 4;
4285         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4286     }
4287     if (width || height) {
4288         size  += 8;
4289         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4290     }
4291     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4292     if (!data)
4293         return AVERROR(ENOMEM);
4294     bytestream_put_le32(&data, flags);
4295     if (channels)
4296         bytestream_put_le32(&data, channels);
4297     if (channel_layout)
4298         bytestream_put_le64(&data, channel_layout);
4299     if (sample_rate)
4300         bytestream_put_le32(&data, sample_rate);
4301     if (width || height) {
4302         bytestream_put_le32(&data, width);
4303         bytestream_put_le32(&data, height);
4304     }
4305     return 0;
4306 }
4307
4308 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4309 {
4310     AVRational undef = {0, 1};
4311     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4312     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4313     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4314
4315     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4316                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4317     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4318         stream_sample_aspect_ratio = undef;
4319
4320     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4321                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4322     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4323         frame_sample_aspect_ratio = undef;
4324
4325     if (stream_sample_aspect_ratio.num)
4326         return stream_sample_aspect_ratio;
4327     else
4328         return frame_sample_aspect_ratio;
4329 }
4330
4331 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4332 {
4333     AVRational fr = st->r_frame_rate;
4334     AVRational codec_fr = st->codec->framerate;
4335     AVRational   avg_fr = st->avg_frame_rate;
4336
4337     if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4338         av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4339         fr = avg_fr;
4340     }
4341
4342
4343     if (st->codec->ticks_per_frame > 1) {
4344         if (   codec_fr.num > 0 && codec_fr.den > 0 &&
4345             (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))
4346             fr = codec_fr;
4347     }
4348
4349     return fr;
4350 }
4351
4352 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4353                                     const char *spec)
4354 {
4355     if (*spec <= '9' && *spec >= '0') /* opt:index */
4356         return strtol(spec, NULL, 0) == st->index;
4357     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4358              *spec == 't' || *spec == 'V') { /* opt:[vasdtV] */
4359         enum AVMediaType type;
4360         int nopic = 0;
4361
4362         switch (*spec++) {
4363         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4364         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4365         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4366         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4367         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4368         case 'V': type = AVMEDIA_TYPE_VIDEO; nopic = 1; break;
4369         default:  av_assert0(0);
4370         }
4371         if (type != st->codec->codec_type)
4372             return 0;
4373         if (nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC))
4374             return 0;
4375         if (*spec++ == ':') { /* possibly followed by :index */
4376             int i, index = strtol(spec, NULL, 0);
4377             for (i = 0; i < s->nb_streams; i++)
4378                 if (s->streams[i]->codec->codec_type == type &&
4379                     !(nopic && (st->disposition & AV_DISPOSITION_ATTACHED_PIC)) &&
4380                     index-- == 0)
4381                     return i == st->index;
4382             return 0;
4383         }
4384         return 1;
4385     } else if (*spec == 'p' && *(spec + 1) == ':') {
4386         int prog_id, i, j;
4387         char *endptr;
4388         spec += 2;
4389         prog_id = strtol(spec, &endptr, 0);
4390         for (i = 0; i < s->nb_programs; i++) {
4391             if (s->programs[i]->id != prog_id)
4392                 continue;
4393
4394             if (*endptr++ == ':') {
4395                 int stream_idx = strtol(endptr, NULL, 0);
4396                 return stream_idx >= 0 &&
4397                     stream_idx < s->programs[i]->nb_stream_indexes &&
4398                     st->index == s->programs[i]->stream_index[stream_idx];
4399             }
4400
4401             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4402                 if (st->index == s->programs[i]->stream_index[j])
4403                     return 1;
4404         }
4405         return 0;
4406     } else if (*spec == '#' ||
4407                (*spec == 'i' && *(spec + 1) == ':')) {
4408         int stream_id;
4409         char *endptr;
4410         spec += 1 + (*spec == 'i');
4411         stream_id = strtol(spec, &endptr, 0);
4412         if (!*endptr)
4413             return stream_id == st->id;
4414     } else if (*spec == 'm' && *(spec + 1) == ':') {
4415         AVDictionaryEntry *tag;
4416         char *key, *val;
4417         int ret;
4418
4419         spec += 2;
4420         val = strchr(spec, ':');
4421
4422         key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4423         if (!key)
4424             return AVERROR(ENOMEM);
4425
4426         tag = av_dict_get(st->metadata, key, NULL, 0);
4427         if (tag) {
4428             if (!val || !strcmp(tag->value, val + 1))
4429                 ret = 1;
4430             else
4431                 ret = 0;
4432         } else
4433             ret = 0;
4434
4435         av_freep(&key);
4436         return ret;
4437     } else if (*spec == 'u') {
4438         AVCodecContext *avctx = st->codec;
4439         int val;
4440         switch (avctx->codec_type) {
4441         case AVMEDIA_TYPE_AUDIO:
4442             val = avctx->sample_rate && avctx->channels;
4443             if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
4444                 return 0;
4445             break;
4446         case AVMEDIA_TYPE_VIDEO:
4447             val = avctx->width && avctx->height;
4448             if (avctx->pix_fmt == AV_PIX_FMT_NONE)
4449                 return 0;
4450             break;
4451         case AVMEDIA_TYPE_UNKNOWN:
4452             val = 0;
4453             break;
4454         default:
4455             val = 1;
4456             break;
4457         }
4458         return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
4459     } else if (!*spec) /* empty specifier, matches everything */
4460         return 1;
4461
4462     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4463     return AVERROR(EINVAL);
4464 }
4465
4466 int ff_generate_avci_extradata(AVStream *st)
4467 {
4468     static const uint8_t avci100_1080p_extradata[] = {
4469         // SPS
4470         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4471         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4472         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4473         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4474         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4475         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4476         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4477         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4478         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4479         // PPS
4480         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4481         0xd0
4482     };
4483     static const uint8_t avci100_1080i_extradata[] = {
4484         // SPS
4485         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4486         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4487         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4488         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4489         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4490         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4491         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4492         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4493         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4494         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4495         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x20,
4496         // PPS
4497         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4498         0xd0
4499     };
4500     static const uint8_t avci50_1080p_extradata[] = {
4501         // SPS
4502         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4503         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4504         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4505         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4506         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4507         0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4508         0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4509         0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4510         0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4511         // PPS
4512         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4513         0x11
4514     };
4515     static const uint8_t avci50_1080i_extradata[] = {
4516         // SPS
4517         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4518         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4519         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4520         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4521         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4522         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4523         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4524         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4525         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4526         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4527         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4528         // PPS
4529         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4530         0x11
4531     };
4532     static const uint8_t avci100_720p_extradata[] = {
4533         // SPS
4534         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4535         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4536         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4537         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4538         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4539         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4540         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4541         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4542         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4543         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4544         // PPS
4545         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4546         0x11
4547     };
4548     static const uint8_t avci50_720p_extradata[] = {
4549         // SPS
4550         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4551         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4552         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4553         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4554         0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4555         0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4556         0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4557         0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4558         0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4559         // PPS
4560         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4561         0x11
4562     };
4563
4564     const uint8_t *data = NULL;
4565     int size            = 0;
4566
4567     if (st->codec->width == 1920) {
4568         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4569             data = avci100_1080p_extradata;
4570             size = sizeof(avci100_1080p_extradata);
4571         } else {
4572             data = avci100_1080i_extradata;
4573             size = sizeof(avci100_1080i_extradata);
4574         }
4575     } else if (st->codec->width == 1440) {
4576         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4577             data = avci50_1080p_extradata;
4578             size = sizeof(avci50_1080p_extradata);
4579         } else {
4580             data = avci50_1080i_extradata;
4581             size = sizeof(avci50_1080i_extradata);
4582         }
4583     } else if (st->codec->width == 1280) {
4584         data = avci100_720p_extradata;
4585         size = sizeof(avci100_720p_extradata);
4586     } else if (st->codec->width == 960) {
4587         data = avci50_720p_extradata;
4588         size = sizeof(avci50_720p_extradata);
4589     }
4590
4591     if (!size)
4592         return 0;
4593
4594     av_freep(&st->codec->extradata);
4595     if (ff_alloc_extradata(st->codec, size))
4596         return AVERROR(ENOMEM);
4597     memcpy(st->codec->extradata, data, size);
4598
4599     return 0;
4600 }
4601
4602 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4603                                  int *size)
4604 {
4605     int i;
4606
4607     for (i = 0; i < st->nb_side_data; i++) {
4608         if (st->side_data[i].type == type) {
4609             if (size)
4610                 *size = st->side_data[i].size;
4611             return st->side_data[i].data;
4612         }
4613     }
4614     return NULL;
4615 }
4616
4617 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
4618                                  int size)
4619 {
4620     AVPacketSideData *sd, *tmp;
4621     int i;
4622     uint8_t *data = av_malloc(size);
4623
4624     if (!data)
4625         return NULL;
4626
4627     for (i = 0; i < st->nb_side_data; i++) {
4628         sd = &st->side_data[i];
4629
4630         if (sd->type == type) {
4631             av_freep(&sd->data);
4632             sd->data = data;
4633             sd->size = size;
4634             return sd->data;
4635         }
4636     }
4637
4638     tmp = av_realloc_array(st->side_data, st->nb_side_data + 1, sizeof(*tmp));
4639     if (!tmp) {
4640         av_freep(&data);
4641         return NULL;
4642     }
4643
4644     st->side_data = tmp;
4645     st->nb_side_data++;
4646
4647     sd = &st->side_data[st->nb_side_data - 1];
4648     sd->type = type;
4649     sd->data = data;
4650     sd->size = size;
4651     return data;
4652 }
4653
4654 int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
4655 {
4656     AVBitStreamFilterContext *bsfc = NULL;
4657     AVBitStreamFilterContext **dest = &st->internal->bsfc;
4658     while (*dest && (*dest)->next)
4659         dest = &(*dest)->next;
4660
4661     if (!(bsfc = av_bitstream_filter_init(name))) {
4662         av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter '%s'\n", name);
4663         return AVERROR(EINVAL);
4664     }
4665     if (args && !(bsfc->args = av_strdup(args))) {
4666         av_bitstream_filter_close(bsfc);
4667         return AVERROR(ENOMEM);
4668     }
4669     av_log(st->codec, AV_LOG_VERBOSE,
4670            "Automatically inserted bitstream filter '%s'; args='%s'\n",
4671            name, args ? args : "");
4672     *dest = bsfc;
4673     return 1;
4674 }
4675
4676 int av_apply_bitstream_filters(AVCodecContext *codec, AVPacket *pkt,
4677                                AVBitStreamFilterContext *bsfc)
4678 {
4679     int ret = 0;
4680     while (bsfc) {
4681         AVPacket new_pkt = *pkt;
4682         int a = av_bitstream_filter_filter(bsfc, codec, NULL,
4683                                            &new_pkt.data, &new_pkt.size,
4684                                            pkt->data, pkt->size,
4685                                            pkt->flags & AV_PKT_FLAG_KEY);
4686         if(a == 0 && new_pkt.data != pkt->data) {
4687             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
4688             if (t) {
4689                 memcpy(t, new_pkt.data, new_pkt.size);
4690                 memset(t + new_pkt.size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
4691                 new_pkt.data = t;
4692                 new_pkt.buf = NULL;
4693                 a = 1;
4694             } else {
4695                 a = AVERROR(ENOMEM);
4696             }
4697         }
4698         if (a > 0) {
4699             new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
4700                                            av_buffer_default_free, NULL, 0);
4701             if (new_pkt.buf) {
4702                 pkt->side_data = NULL;
4703                 pkt->side_data_elems = 0;
4704                 av_packet_unref(pkt);
4705             } else {
4706                 av_freep(&new_pkt.data);
4707                 a = AVERROR(ENOMEM);
4708             }
4709         }
4710         if (a < 0) {
4711             av_log(codec, AV_LOG_ERROR,
4712                    "Failed to open bitstream filter %s for stream %d with codec %s",
4713                    bsfc->filter->name, pkt->stream_index,
4714                    codec->codec ? codec->codec->name : "copy");
4715             ret = a;
4716             break;
4717         }
4718         *pkt = new_pkt;
4719
4720         bsfc = bsfc->next;
4721     }
4722     return ret;
4723 }