git.sesse.net Git - ffmpeg/blob - libavformat/utils.c

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