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