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

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