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

   1 /*
   2  * various utility functions for use within Libav
   3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #undef NDEBUG
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <stdint.h>
  26
  27 #include "config.h"
  28
  29 #include "libavutil/avassert.h"
  30 #include "libavutil/avstring.h"
  31 #include "libavutil/dict.h"
  32 #include "libavutil/internal.h"
  33 #include "libavutil/mathematics.h"
  34 #include "libavutil/opt.h"
  35 #include "libavutil/parseutils.h"
  36 #include "libavutil/pixdesc.h"
  37 #include "libavutil/time.h"
  38
  39 #include "libavcodec/bytestream.h"
  40 #include "libavcodec/internal.h"
  41
  42 #include "audiointerleave.h"
  43 #include "avformat.h"
  44 #include "id3v2.h"
  45 #include "internal.h"
  46 #include "metadata.h"
  47 #if CONFIG_NETWORK
  48 #include "network.h"
  49 #endif
  50 #include "riff.h"
  51 #include "url.h"
  52
  53 /**
  54  * @file
  55  * various utility functions for use within Libav
  56  */
  57
  58 unsigned avformat_version(void)
  59 {
  60     return LIBAVFORMAT_VERSION_INT;
  61 }
  62
  63 const char *avformat_configuration(void)
  64 {
  65     return LIBAV_CONFIGURATION;
  66 }
  67
  68 const char *avformat_license(void)
  69 {
  70 #define LICENSE_PREFIX "libavformat license: "
  71     return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  72 }
  73
  74 /* an arbitrarily chosen "sane" max packet size -- 50M */
  75 #define SANE_CHUNK_SIZE (50000000)
  76
  77 /* Read the data in sane-sized chunks and append to pkt.
  78  * Return the number of bytes read or an error. */
  79 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
  80 {
  81     int64_t chunk_size = size;
  82     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
  83     int orig_size      = pkt->size;
  84     int ret = 0;
  85
  86     do {
  87         int prev_size = pkt->size;
  88         int read_size;
  89
  90         /* When the caller requests a lot of data, limit it to the amount
  91          * left in file or SANE_CHUNK_SIZE when it is not known. */
  92         if (size > SANE_CHUNK_SIZE) {
  93             int64_t filesize = avio_size(s) - avio_tell(s);
  94             chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
  95         }
  96         read_size = FFMIN(size, chunk_size);
  97
  98         ret = av_grow_packet(pkt, read_size);
  99         if (ret < 0)
 100             break;
 101
 102         ret = avio_read(s, pkt->data + prev_size, read_size);
 103         if (ret != read_size) {
 104             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
 105             break;
 106         }
 107
 108         size -= read_size;
 109     } while (size > 0);
 110
 111     pkt->pos = orig_pos;
 112     if (!pkt->size)
 113         av_packet_unref(pkt);
 114     return pkt->size > orig_size ? pkt->size - orig_size : ret;
 115 }
 116
 117 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
 118 {
 119     av_init_packet(pkt);
 120     pkt->data = NULL;
 121     pkt->size = 0;
 122     pkt->pos  = avio_tell(s);
 123
 124     return append_packet_chunked(s, pkt, size);
 125 }
 126
 127 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
 128 {
 129     if (!pkt->size)
 130         return av_get_packet(s, pkt, size);
 131     return append_packet_chunked(s, pkt, size);
 132 }
 133
 134 int av_filename_number_test(const char *filename)
 135 {
 136     char buf[1024];
 137     return filename &&
 138            (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
 139 }
 140
 141 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
 142                                      AVProbeData *pd, int score)
 143 {
 144     static const struct {
 145         const char *name;
 146         enum AVCodecID id;
 147         enum AVMediaType type;
 148     } fmt_id_type[] = {
 149         { "aac",       AV_CODEC_ID_AAC,        AVMEDIA_TYPE_AUDIO },
 150         { "ac3",       AV_CODEC_ID_AC3,        AVMEDIA_TYPE_AUDIO },
 151         { "dts",       AV_CODEC_ID_DTS,        AVMEDIA_TYPE_AUDIO },
 152         { "eac3",      AV_CODEC_ID_EAC3,       AVMEDIA_TYPE_AUDIO },
 153         { "h264",      AV_CODEC_ID_H264,       AVMEDIA_TYPE_VIDEO },
 154         { "latm",      AV_CODEC_ID_AAC_LATM,   AVMEDIA_TYPE_AUDIO },
 155         { "m4v",       AV_CODEC_ID_MPEG4,      AVMEDIA_TYPE_VIDEO },
 156         { "mp3",       AV_CODEC_ID_MP3,        AVMEDIA_TYPE_AUDIO },
 157         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
 158         { 0 }
 159     };
 160     AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
 161
 162     if (fmt) {
 163         int i;
 164         av_log(s, AV_LOG_DEBUG,
 165                "Probe with size=%d, packets=%d detected %s with score=%d\n",
 166                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
 167                fmt->name, score);
 168         for (i = 0; fmt_id_type[i].name; i++) {
 169             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
 170                 st->codecpar->codec_id   = fmt_id_type[i].id;
 171                 st->codecpar->codec_type = fmt_id_type[i].type;
 172 #if FF_API_LAVF_AVCTX
 173 FF_DISABLE_DEPRECATION_WARNINGS
 174                 st->codec->codec_type = st->codecpar->codec_type;
 175                 st->codec->codec_id   = st->codecpar->codec_id;
 176 FF_ENABLE_DEPRECATION_WARNINGS
 177 #endif
 178                 break;
 179             }
 180         }
 181     }
 182     return !!fmt;
 183 }
 184
 185 /************************************************************/
 186 /* input media file */
 187
 188 /* Open input file and probe the format if necessary. */
 189 static int init_input(AVFormatContext *s, const char *filename,
 190                       AVDictionary **options)
 191 {
 192     int ret;
 193     AVProbeData pd = { filename, NULL, 0 };
 194
 195     if (s->pb) {
 196         s->flags |= AVFMT_FLAG_CUSTOM_IO;
 197         if (!s->iformat)
 198             return av_probe_input_buffer(s->pb, &s->iformat, filename,
 199                                          s, 0, s->probesize);
 200         else if (s->iformat->flags & AVFMT_NOFILE)
 201             return AVERROR(EINVAL);
 202         return 0;
 203     }
 204
 205     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
 206         (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
 207         return 0;
 208
 209     ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ, options);
 210     if (ret < 0)
 211         return ret;
 212     if (s->iformat)
 213         return 0;
 214     return av_probe_input_buffer(s->pb, &s->iformat, filename,
 215                                  s, 0, s->probesize);
 216 }
 217
 218 static int add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
 219                          AVPacketList **plast_pktl, int ref)
 220 {
 221     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
 222     int ret;
 223
 224     if (!pktl)
 225         return AVERROR(ENOMEM);
 226
 227     if (ref) {
 228         if ((ret = av_packet_ref(&pktl->pkt, pkt)) < 0) {
 229             av_free(pktl);
 230             return ret;
 231         }
 232     } else {
 233         pktl->pkt = *pkt;
 234     }
 235
 236     if (*packet_buffer)
 237         (*plast_pktl)->next = pktl;
 238     else
 239         *packet_buffer = pktl;
 240
 241     /* Add the packet in the buffered packet list. */
 242     *plast_pktl = pktl;
 243     return 0;
 244 }
 245
 246 static int queue_attached_pictures(AVFormatContext *s)
 247 {
 248     int i, ret;
 249     for (i = 0; i < s->nb_streams; i++)
 250         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
 251             s->streams[i]->discard < AVDISCARD_ALL) {
 252
 253             ret = add_to_pktbuf(&s->internal->raw_packet_buffer,
 254                                 &s->streams[i]->attached_pic,
 255                                 &s->internal->raw_packet_buffer_end, 1);
 256             if (ret < 0)
 257                 return ret;
 258         }
 259     return 0;
 260 }
 261
 262 #if FF_API_LAVF_AVCTX
 263 FF_DISABLE_DEPRECATION_WARNINGS
 264 static int update_stream_avctx(AVFormatContext *s)
 265 {
 266     int i, ret;
 267     for (i = 0; i < s->nb_streams; i++) {
 268         AVStream *st = s->streams[i];
 269
 270         if (!st->internal->need_codec_update)
 271             continue;
 272
 273         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
 274         if (ret < 0)
 275             return ret;
 276
 277         st->internal->need_codec_update = 0;
 278     }
 279     return 0;
 280 }
 281 FF_ENABLE_DEPRECATION_WARNINGS
 282 #endif
 283
 284 int avformat_open_input(AVFormatContext **ps, const char *filename,
 285                         AVInputFormat *fmt, AVDictionary **options)
 286 {
 287     AVFormatContext *s = *ps;
 288     int i, ret = 0;
 289     AVDictionary *tmp = NULL;
 290     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
 291
 292     if (!s && !(s = avformat_alloc_context()))
 293         return AVERROR(ENOMEM);
 294     if (fmt)
 295         s->iformat = fmt;
 296
 297     if (options)
 298         av_dict_copy(&tmp, *options, 0);
 299
 300     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
 301         goto fail;
 302
 303     if ((ret = init_input(s, filename, &tmp)) < 0)
 304         goto fail;
 305
 306     /* Check filename in case an image number is expected. */
 307     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
 308         if (!av_filename_number_test(filename)) {
 309             ret = AVERROR(EINVAL);
 310             goto fail;
 311         }
 312     }
 313
 314     s->duration = s->start_time = AV_NOPTS_VALUE;
 315     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
 316
 317     /* Allocate private data. */
 318     if (s->iformat->priv_data_size > 0) {
 319         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
 320             ret = AVERROR(ENOMEM);
 321             goto fail;
 322         }
 323         if (s->iformat->priv_class) {
 324             *(const AVClass **) s->priv_data = s->iformat->priv_class;
 325             av_opt_set_defaults(s->priv_data);
 326             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
 327                 goto fail;
 328         }
 329     }
 330
 331     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
 332     if (s->pb)
 333         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
 334
 335     if (s->iformat->read_header)
 336         if ((ret = s->iformat->read_header(s)) < 0)
 337             goto fail;
 338
 339     if (id3v2_extra_meta &&
 340         (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
 341         goto fail;
 342     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 343
 344     if ((ret = queue_attached_pictures(s)) < 0)
 345         goto fail;
 346
 347     if (s->pb && !s->internal->data_offset)
 348         s->internal->data_offset = avio_tell(s->pb);
 349
 350     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
 351
 352 #if FF_API_LAVF_AVCTX
 353     update_stream_avctx(s);
 354 #endif
 355
 356     for (i = 0; i < s->nb_streams; i++)
 357         s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
 358
 359     if (options) {
 360         av_dict_free(options);
 361         *options = tmp;
 362     }
 363     *ps = s;
 364     return 0;
 365
 366 fail:
 367     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
 368     av_dict_free(&tmp);
 369     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
 370         avio_close(s->pb);
 371     avformat_free_context(s);
 372     *ps = NULL;
 373     return ret;
 374 }
 375
 376 /*******************************************************/
 377
 378 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
 379 {
 380     if (st->codecpar->codec_id == AV_CODEC_ID_PROBE) {
 381         AVProbeData *pd = &st->probe_data;
 382         av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
 383         --st->probe_packets;
 384
 385         if (pkt) {
 386             int err;
 387             if ((err = av_reallocp(&pd->buf, pd->buf_size + pkt->size +
 388                                    AVPROBE_PADDING_SIZE)) < 0)
 389                 return err;
 390             memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
 391             pd->buf_size += pkt->size;
 392             memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
 393         } else {
 394             st->probe_packets = 0;
 395             if (!pd->buf_size) {
 396                 av_log(s, AV_LOG_ERROR,
 397                        "nothing to probe for stream %d\n", st->index);
 398                 return 0;
 399             }
 400         }
 401
 402         if (!st->probe_packets ||
 403             av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
 404             set_codec_from_probe_data(s, st, pd, st->probe_packets > 0
 405                                                  ? AVPROBE_SCORE_MAX / 4 : 0);
 406             if (st->codecpar->codec_id != AV_CODEC_ID_PROBE) {
 407                 pd->buf_size = 0;
 408                 av_freep(&pd->buf);
 409                 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
 410             }
 411         }
 412     }
 413     return 0;
 414 }
 415
 416 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
 417 {
 418     int ret, i, err;
 419     AVStream *st;
 420
 421     for (;;) {
 422         AVPacketList *pktl = s->internal->raw_packet_buffer;
 423
 424         if (pktl) {
 425             *pkt = pktl->pkt;
 426             st   = s->streams[pkt->stream_index];
 427             if (st->codecpar->codec_id != AV_CODEC_ID_PROBE ||
 428                 !st->probe_packets ||
 429                 s->internal->raw_packet_buffer_remaining_size < pkt->size) {
 430                 AVProbeData *pd;
 431                 if (st->probe_packets)
 432                     if ((err = probe_codec(s, st, NULL)) < 0)
 433                         return err;
 434                 pd = &st->probe_data;
 435                 av_freep(&pd->buf);
 436                 pd->buf_size = 0;
 437                 s->internal->raw_packet_buffer                 = pktl->next;
 438                 s->internal->raw_packet_buffer_remaining_size += pkt->size;
 439                 av_free(pktl);
 440                 return 0;
 441             }
 442         }
 443
 444         pkt->data = NULL;
 445         pkt->size = 0;
 446         av_init_packet(pkt);
 447         ret = s->iformat->read_packet(s, pkt);
 448         if (ret < 0) {
 449             if (!pktl || ret == AVERROR(EAGAIN))
 450                 return ret;
 451             for (i = 0; i < s->nb_streams; i++) {
 452                 st = s->streams[i];
 453                 if (st->probe_packets)
 454                     if ((err = probe_codec(s, st, NULL)) < 0)
 455                         return err;
 456             }
 457             continue;
 458         }
 459
 460         if (!pkt->buf) {
 461             AVPacket tmp = { 0 };
 462             ret = av_packet_ref(&tmp, pkt);
 463             if (ret < 0)
 464                 return ret;
 465             *pkt = tmp;
 466         }
 467
 468         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
 469             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
 470             av_log(s, AV_LOG_WARNING,
 471                    "Dropped corrupted packet (stream = %d)\n",
 472                    pkt->stream_index);
 473             av_packet_unref(pkt);
 474             continue;
 475         }
 476
 477         st = s->streams[pkt->stream_index];
 478
 479         switch (st->codecpar->codec_type) {
 480         case AVMEDIA_TYPE_VIDEO:
 481             if (s->video_codec_id)
 482                 st->codecpar->codec_id = s->video_codec_id;
 483             break;
 484         case AVMEDIA_TYPE_AUDIO:
 485             if (s->audio_codec_id)
 486                 st->codecpar->codec_id = s->audio_codec_id;
 487             break;
 488         case AVMEDIA_TYPE_SUBTITLE:
 489             if (s->subtitle_codec_id)
 490                 st->codecpar->codec_id = s->subtitle_codec_id;
 491             break;
 492         }
 493
 494         if (!pktl && (st->codecpar->codec_id != AV_CODEC_ID_PROBE ||
 495                       !st->probe_packets))
 496             return ret;
 497
 498         err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
 499                             &s->internal->raw_packet_buffer_end, 0);
 500         if (err)
 501             return err;
 502         s->internal->raw_packet_buffer_remaining_size -= pkt->size;
 503
 504         if ((err = probe_codec(s, st, pkt)) < 0)
 505             return err;
 506     }
 507 }
 508
 509 /**********************************************************/
 510
 511 /**
 512  * Return the frame duration in seconds. Return 0 if not available.
 513  */
 514 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
 515                                AVCodecParserContext *pc, AVPacket *pkt)
 516 {
 517     AVRational codec_framerate = s->iformat ? st->internal->avctx->framerate :
 518                                               (AVRational){ 0, 1 };
 519     int frame_size;
 520
 521     *pnum = 0;
 522     *pden = 0;
 523     switch (st->codecpar->codec_type) {
 524     case AVMEDIA_TYPE_VIDEO:
 525         if (st->avg_frame_rate.num) {
 526             *pnum = st->avg_frame_rate.den;
 527             *pden = st->avg_frame_rate.num;
 528         } else if (st->time_base.num * 1000LL > st->time_base.den) {
 529             *pnum = st->time_base.num;
 530             *pden = st->time_base.den;
 531         } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
 532             *pnum = codec_framerate.den;
 533             *pden = codec_framerate.num;
 534             if (pc && pc->repeat_pict) {
 535                 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
 536                     *pden /= 1 + pc->repeat_pict;
 537                 else
 538                     *pnum *= 1 + pc->repeat_pict;
 539             }
 540             /* If this codec can be interlaced or progressive then we need
 541              * a parser to compute duration of a packet. Thus if we have
 542              * no parser in such case leave duration undefined. */
 543             if (st->internal->avctx->ticks_per_frame > 1 && !pc)
 544                 *pnum = *pden = 0;
 545         }
 546         break;
 547     case AVMEDIA_TYPE_AUDIO:
 548         frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
 549         if (frame_size <= 0 || st->codecpar->sample_rate <= 0)
 550             break;
 551         *pnum = frame_size;
 552         *pden = st->codecpar->sample_rate;
 553         break;
 554     default:
 555         break;
 556     }
 557 }
 558
 559 static int is_intra_only(enum AVCodecID id)
 560 {
 561     const AVCodecDescriptor *d = avcodec_descriptor_get(id);
 562     if (!d)
 563         return 0;
 564     if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
 565         return 0;
 566     return 1;
 567 }
 568
 569 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
 570                                       int64_t dts, int64_t pts)
 571 {
 572     AVStream *st       = s->streams[stream_index];
 573     AVPacketList *pktl = s->internal->packet_buffer;
 574
 575     if (st->first_dts != AV_NOPTS_VALUE ||
 576         dts           == AV_NOPTS_VALUE ||
 577         st->cur_dts   == AV_NOPTS_VALUE)
 578         return;
 579
 580     st->first_dts = dts - st->cur_dts;
 581     st->cur_dts   = dts;
 582
 583     for (; pktl; pktl = pktl->next) {
 584         if (pktl->pkt.stream_index != stream_index)
 585             continue;
 586         // FIXME: think more about this check
 587         if (pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
 588             pktl->pkt.pts += st->first_dts;
 589
 590         if (pktl->pkt.dts != AV_NOPTS_VALUE)
 591             pktl->pkt.dts += st->first_dts;
 592
 593         if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
 594             st->start_time = pktl->pkt.pts;
 595     }
 596     if (st->start_time == AV_NOPTS_VALUE)
 597         st->start_time = pts;
 598 }
 599
 600 static void update_initial_durations(AVFormatContext *s, AVStream *st,
 601                                      int stream_index, int duration)
 602 {
 603     AVPacketList *pktl = s->internal->packet_buffer;
 604     int64_t cur_dts    = 0;
 605
 606     if (st->first_dts != AV_NOPTS_VALUE) {
 607         cur_dts = st->first_dts;
 608         for (; pktl; pktl = pktl->next) {
 609             if (pktl->pkt.stream_index == stream_index) {
 610                 if (pktl->pkt.pts != pktl->pkt.dts  ||
 611                     pktl->pkt.dts != AV_NOPTS_VALUE ||
 612                     pktl->pkt.duration)
 613                     break;
 614                 cur_dts -= duration;
 615             }
 616         }
 617         pktl          = s->internal->packet_buffer;
 618         st->first_dts = cur_dts;
 619     } else if (st->cur_dts)
 620         return;
 621
 622     for (; pktl; pktl = pktl->next) {
 623         if (pktl->pkt.stream_index != stream_index)
 624             continue;
 625         if (pktl->pkt.pts == pktl->pkt.dts  &&
 626             pktl->pkt.dts == AV_NOPTS_VALUE &&
 627             !pktl->pkt.duration) {
 628             pktl->pkt.dts = cur_dts;
 629             if (!st->internal->avctx->has_b_frames)
 630                 pktl->pkt.pts = cur_dts;
 631             cur_dts += duration;
 632             if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
 633                 pktl->pkt.duration = duration;
 634         } else
 635             break;
 636     }
 637     if (st->first_dts == AV_NOPTS_VALUE)
 638         st->cur_dts = cur_dts;
 639 }
 640
 641 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
 642                                AVCodecParserContext *pc, AVPacket *pkt)
 643 {
 644     int num, den, presentation_delayed, delay, i;
 645     int64_t offset;
 646
 647     if (s->flags & AVFMT_FLAG_NOFILLIN)
 648         return;
 649
 650     if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
 651         pkt->dts = AV_NOPTS_VALUE;
 652
 653     /* do we have a video B-frame ? */
 654     delay = st->internal->avctx->has_b_frames;
 655     presentation_delayed = 0;
 656
 657     /* XXX: need has_b_frame, but cannot get it if the codec is
 658      *  not initialized */
 659     if (delay &&
 660         pc && pc->pict_type != AV_PICTURE_TYPE_B)
 661         presentation_delayed = 1;
 662
 663     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
 664         st->pts_wrap_bits < 63 &&
 665         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
 666         pkt->dts -= 1LL << st->pts_wrap_bits;
 667     }
 668
 669     /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
 670      * We take the conservative approach and discard both.
 671      * Note: If this is misbehaving for an H.264 file, then possibly
 672      * presentation_delayed is not set correctly. */
 673     if (delay == 1 && pkt->dts == pkt->pts &&
 674         pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
 675         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
 676         pkt->dts = AV_NOPTS_VALUE;
 677     }
 678
 679     if (pkt->duration == 0 && st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
 680         ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
 681         if (den && num) {
 682             pkt->duration = av_rescale_rnd(1, num * (int64_t) st->time_base.den,
 683                                            den * (int64_t) st->time_base.num,
 684                                            AV_ROUND_DOWN);
 685
 686             if (pkt->duration != 0 && s->internal->packet_buffer)
 687                 update_initial_durations(s, st, pkt->stream_index,
 688                                          pkt->duration);
 689         }
 690     }
 691
 692     /* Correct timestamps with byte offset if demuxers only have timestamps
 693      * on packet boundaries */
 694     if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
 695         /* this will estimate bitrate based on this frame's duration and size */
 696         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
 697         if (pkt->pts != AV_NOPTS_VALUE)
 698             pkt->pts += offset;
 699         if (pkt->dts != AV_NOPTS_VALUE)
 700             pkt->dts += offset;
 701     }
 702
 703     /* This may be redundant, but it should not hurt. */
 704     if (pkt->dts != AV_NOPTS_VALUE &&
 705         pkt->pts != AV_NOPTS_VALUE &&
 706         pkt->pts > pkt->dts)
 707         presentation_delayed = 1;
 708
 709     av_log(NULL, AV_LOG_TRACE,
 710             "IN delayed:%d pts:%"PRId64", dts:%"PRId64" "
 711             "cur_dts:%"PRId64" st:%d pc:%p\n",
 712             presentation_delayed, pkt->pts, pkt->dts, st->cur_dts,
 713             pkt->stream_index, pc);
 714     /* Interpolate PTS and DTS if they are not present. We skip H.264
 715      * currently because delay and has_b_frames are not reliably set. */
 716     if ((delay == 0 || (delay == 1 && pc)) &&
 717         st->codecpar->codec_id != AV_CODEC_ID_H264) {
 718         if (presentation_delayed) {
 719             /* DTS = decompression timestamp */
 720             /* PTS = presentation timestamp */
 721             if (pkt->dts == AV_NOPTS_VALUE)
 722                 pkt->dts = st->last_IP_pts;
 723             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
 724             if (pkt->dts == AV_NOPTS_VALUE)
 725                 pkt->dts = st->cur_dts;
 726
 727             /* This is tricky: the dts must be incremented by the duration
 728              * of the frame we are displaying, i.e. the last I- or P-frame. */
 729             if (st->last_IP_duration == 0)
 730                 st->last_IP_duration = pkt->duration;
 731             if (pkt->dts != AV_NOPTS_VALUE)
 732                 st->cur_dts = pkt->dts + st->last_IP_duration;
 733             st->last_IP_duration = pkt->duration;
 734             st->last_IP_pts      = pkt->pts;
 735             /* Cannot compute PTS if not present (we can compute it only
 736              * by knowing the future. */
 737         } else if (pkt->pts != AV_NOPTS_VALUE ||
 738                    pkt->dts != AV_NOPTS_VALUE ||
 739                    pkt->duration              ||
 740                    st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
 741             int duration = pkt->duration;
 742             if (!duration && st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
 743                 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
 744                 if (den && num) {
 745                     duration = av_rescale_rnd(1,
 746                                               num * (int64_t) st->time_base.den,
 747                                               den * (int64_t) st->time_base.num,
 748                                               AV_ROUND_DOWN);
 749                     if (duration != 0 && s->internal->packet_buffer)
 750                         update_initial_durations(s, st, pkt->stream_index,
 751                                                  duration);
 752                 }
 753             }
 754
 755             if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
 756                 duration) {
 757                 /* presentation is not delayed : PTS and DTS are the same */
 758                 if (pkt->pts == AV_NOPTS_VALUE)
 759                     pkt->pts = pkt->dts;
 760                 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
 761                                           pkt->pts);
 762                 if (pkt->pts == AV_NOPTS_VALUE)
 763                     pkt->pts = st->cur_dts;
 764                 pkt->dts = pkt->pts;
 765                 if (pkt->pts != AV_NOPTS_VALUE)
 766                     st->cur_dts = pkt->pts + duration;
 767             }
 768         }
 769     }
 770
 771     if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
 772         st->pts_buffer[0] = pkt->pts;
 773         for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
 774             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
 775         if (pkt->dts == AV_NOPTS_VALUE)
 776             pkt->dts = st->pts_buffer[0];
 777         // We skipped it above so we try here.
 778         if (st->codecpar->codec_id == AV_CODEC_ID_H264)
 779             // This should happen on the first packet
 780             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
 781         if (pkt->dts > st->cur_dts)
 782             st->cur_dts = pkt->dts;
 783     }
 784
 785     av_log(NULL, AV_LOG_TRACE,
 786             "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
 787             presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
 788
 789     /* update flags */
 790     if (is_intra_only(st->codecpar->codec_id))
 791         pkt->flags |= AV_PKT_FLAG_KEY;
 792 #if FF_API_CONVERGENCE_DURATION
 793 FF_DISABLE_DEPRECATION_WARNINGS
 794     if (pc)
 795         pkt->convergence_duration = pc->convergence_duration;
 796 FF_ENABLE_DEPRECATION_WARNINGS
 797 #endif
 798 }
 799
 800 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
 801 {
 802     while (*pkt_buf) {
 803         AVPacketList *pktl = *pkt_buf;
 804         *pkt_buf = pktl->next;
 805         av_packet_unref(&pktl->pkt);
 806         av_freep(&pktl);
 807     }
 808     *pkt_buf_end = NULL;
 809 }
 810
 811 /**
 812  * Parse a packet, add all split parts to parse_queue.
 813  *
 814  * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
 815  */
 816 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
 817 {
 818     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
 819     AVStream *st = s->streams[stream_index];
 820     uint8_t *data = pkt ? pkt->data : NULL;
 821     int size      = pkt ? pkt->size : 0;
 822     int ret = 0, got_output = 0;
 823
 824     if (!pkt) {
 825         av_init_packet(&flush_pkt);
 826         pkt        = &flush_pkt;
 827         got_output = 1;
 828     }
 829
 830     while (size > 0 || (pkt == &flush_pkt && got_output)) {
 831         int len;
 832
 833         av_init_packet(&out_pkt);
 834         len = av_parser_parse2(st->parser, st->internal->avctx,
 835                                &out_pkt.data, &out_pkt.size, data, size,
 836                                pkt->pts, pkt->dts, pkt->pos);
 837
 838         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
 839         /* increment read pointer */
 840         data += len;
 841         size -= len;
 842
 843         got_output = !!out_pkt.size;
 844
 845         if (!out_pkt.size)
 846             continue;
 847
 848         if (pkt->side_data) {
 849             out_pkt.side_data       = pkt->side_data;
 850             out_pkt.side_data_elems = pkt->side_data_elems;
 851             pkt->side_data          = NULL;
 852             pkt->side_data_elems    = 0;
 853         }
 854
 855         /* set the duration */
 856         out_pkt.duration = 0;
 857         if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
 858             if (st->internal->avctx->sample_rate > 0) {
 859                 out_pkt.duration =
 860                     av_rescale_q_rnd(st->parser->duration,
 861                                      (AVRational) { 1, st->internal->avctx->sample_rate },
 862                                      st->time_base,
 863                                      AV_ROUND_DOWN);
 864             }
 865         }
 866
 867         out_pkt.stream_index = st->index;
 868         out_pkt.pts          = st->parser->pts;
 869         out_pkt.dts          = st->parser->dts;
 870         out_pkt.pos          = st->parser->pos;
 871
 872         if (st->parser->key_frame == 1 ||
 873             (st->parser->key_frame == -1 &&
 874              st->parser->pict_type == AV_PICTURE_TYPE_I))
 875             out_pkt.flags |= AV_PKT_FLAG_KEY;
 876
 877         compute_pkt_fields(s, st, st->parser, &out_pkt);
 878
 879         if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
 880             out_pkt.flags & AV_PKT_FLAG_KEY) {
 881             ff_reduce_index(s, st->index);
 882             av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
 883                                0, 0, AVINDEX_KEYFRAME);
 884         }
 885
 886         if ((ret = add_to_pktbuf(&s->internal->parse_queue, &out_pkt,
 887                                  &s->internal->parse_queue_end,
 888                                  1))) {
 889             av_packet_unref(&out_pkt);
 890             goto fail;
 891         }
 892     }
 893
 894     /* end of the stream => close and free the parser */
 895     if (pkt == &flush_pkt) {
 896         av_parser_close(st->parser);
 897         st->parser = NULL;
 898     }
 899
 900 fail:
 901     av_packet_unref(pkt);
 902     return ret;
 903 }
 904
 905 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
 906                                    AVPacketList **pkt_buffer_end,
 907                                    AVPacket      *pkt)
 908 {
 909     AVPacketList *pktl;
 910     av_assert0(*pkt_buffer);
 911     pktl        = *pkt_buffer;
 912     *pkt        = pktl->pkt;
 913     *pkt_buffer = pktl->next;
 914     if (!pktl->next)
 915         *pkt_buffer_end = NULL;
 916     av_freep(&pktl);
 917     return 0;
 918 }
 919
 920 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
 921 {
 922     int ret = 0, i, got_packet = 0;
 923     AVDictionary *metadata = NULL;
 924
 925     av_init_packet(pkt);
 926
 927     while (!got_packet && !s->internal->parse_queue) {
 928         AVStream *st;
 929         AVPacket cur_pkt;
 930
 931         /* read next packet */
 932         ret = ff_read_packet(s, &cur_pkt);
 933         if (ret < 0) {
 934             if (ret == AVERROR(EAGAIN))
 935                 return ret;
 936             /* flush the parsers */
 937             for (i = 0; i < s->nb_streams; i++) {
 938                 st = s->streams[i];
 939                 if (st->parser && st->need_parsing)
 940                     parse_packet(s, NULL, st->index);
 941             }
 942             /* all remaining packets are now in parse_queue =>
 943              * really terminate parsing */
 944             break;
 945         }
 946         ret = 0;
 947         st  = s->streams[cur_pkt.stream_index];
 948
 949         if (cur_pkt.pts != AV_NOPTS_VALUE &&
 950             cur_pkt.dts != AV_NOPTS_VALUE &&
 951             cur_pkt.pts < cur_pkt.dts) {
 952             av_log(s, AV_LOG_WARNING,
 953                    "Invalid timestamps stream=%d, pts=%"PRId64", "
 954                    "dts=%"PRId64", size=%d\n",
 955                    cur_pkt.stream_index, cur_pkt.pts,
 956                    cur_pkt.dts, cur_pkt.size);
 957         }
 958         if (s->debug & FF_FDEBUG_TS)
 959             av_log(s, AV_LOG_DEBUG,
 960                    "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", "
 961                    "size=%d, duration=%"PRId64", flags=%d\n",
 962                    cur_pkt.stream_index, cur_pkt.pts, cur_pkt.dts,
 963                    cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
 964
 965         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
 966             st->parser = av_parser_init(st->codecpar->codec_id);
 967             if (!st->parser)
 968                 /* no parser available: just output the raw packets */
 969                 st->need_parsing = AVSTREAM_PARSE_NONE;
 970             else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
 971                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
 972             else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
 973                 st->parser->flags |= PARSER_FLAG_ONCE;
 974         }
 975
 976         if (!st->need_parsing || !st->parser) {
 977             /* no parsing needed: we just output the packet as is */
 978             *pkt = cur_pkt;
 979             compute_pkt_fields(s, st, NULL, pkt);
 980             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
 981                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
 982                 ff_reduce_index(s, st->index);
 983                 av_add_index_entry(st, pkt->pos, pkt->dts,
 984                                    0, 0, AVINDEX_KEYFRAME);
 985             }
 986             got_packet = 1;
 987         } else if (st->discard < AVDISCARD_ALL) {
 988             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
 989                 return ret;
 990         } else {
 991             /* free packet */
 992             av_packet_unref(&cur_pkt);
 993         }
 994     }
 995
 996     if (!got_packet && s->internal->parse_queue)
 997         ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);
 998
 999     av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1000     if (metadata) {
1001         s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1002         av_dict_copy(&s->metadata, metadata, 0);
1003         av_dict_free(&metadata);
1004         av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1005     }
1006
1007 #if FF_API_LAVF_AVCTX
1008     update_stream_avctx(s);
1009 #endif
1010
1011     if (s->debug & FF_FDEBUG_TS)
1012         av_log(s, AV_LOG_DEBUG,
1013                "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", "
1014                "size=%d, duration=%"PRId64", flags=%d\n",
1015                pkt->stream_index, pkt->pts, pkt->dts,
1016                pkt->size, pkt->duration, pkt->flags);
1017
1018     return ret;
1019 }
1020
1021 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1022 {
1023     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1024     int eof = 0;
1025
1026     if (!genpts)
1027         return s->internal->packet_buffer
1028                ? read_from_packet_buffer(&s->internal->packet_buffer,
1029                                          &s->internal->packet_buffer_end, pkt)
1030                : read_frame_internal(s, pkt);
1031
1032     for (;;) {
1033         int ret;
1034         AVPacketList *pktl = s->internal->packet_buffer;
1035
1036         if (pktl) {
1037             AVPacket *next_pkt = &pktl->pkt;
1038
1039             if (next_pkt->dts != AV_NOPTS_VALUE) {
1040                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1041                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1042                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1043                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1044                          av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1045                         // not B-frame
1046                         next_pkt->pts = pktl->pkt.dts;
1047                     }
1048                     pktl = pktl->next;
1049                 }
1050                 pktl = s->internal->packet_buffer;
1051             }
1052
1053             /* read packet from packet buffer, if there is data */
1054             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1055                   next_pkt->dts != AV_NOPTS_VALUE && !eof))
1056                 return read_from_packet_buffer(&s->internal->packet_buffer,
1057                                                &s->internal->packet_buffer_end, pkt);
1058         }
1059
1060         ret = read_frame_internal(s, pkt);
1061         if (ret < 0) {
1062             if (pktl && ret != AVERROR(EAGAIN)) {
1063                 eof = 1;
1064                 continue;
1065             } else
1066                 return ret;
1067         }
1068
1069         ret = add_to_pktbuf(&s->internal->packet_buffer, pkt,
1070                             &s->internal->packet_buffer_end, 1);
1071         if (ret < 0)
1072             return ret;
1073     }
1074 }
1075
1076 /* XXX: suppress the packet queue */
1077 static void flush_packet_queue(AVFormatContext *s)
1078 {
1079     free_packet_buffer(&s->internal->parse_queue,       &s->internal->parse_queue_end);
1080     free_packet_buffer(&s->internal->packet_buffer,     &s->internal->packet_buffer_end);
1081     free_packet_buffer(&s->internal->raw_packet_buffer, &s->internal->raw_packet_buffer_end);
1082
1083     s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1084 }
1085
1086 /*******************************************************/
1087 /* seek support */
1088
1089 int av_find_default_stream_index(AVFormatContext *s)
1090 {
1091     int first_audio_index = -1;
1092     int i;
1093     AVStream *st;
1094
1095     if (s->nb_streams <= 0)
1096         return -1;
1097     for (i = 0; i < s->nb_streams; i++) {
1098         st = s->streams[i];
1099         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1100             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1101             return i;
1102         }
1103         if (first_audio_index < 0 &&
1104             st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
1105             first_audio_index = i;
1106     }
1107     return first_audio_index >= 0 ? first_audio_index : 0;
1108 }
1109
1110 /** Flush the frame reader. */
1111 void ff_read_frame_flush(AVFormatContext *s)
1112 {
1113     AVStream *st;
1114     int i, j;
1115
1116     flush_packet_queue(s);
1117
1118     /* Reset read state for each stream. */
1119     for (i = 0; i < s->nb_streams; i++) {
1120         st = s->streams[i];
1121
1122         if (st->parser) {
1123             av_parser_close(st->parser);
1124             st->parser = NULL;
1125         }
1126         st->last_IP_pts = AV_NOPTS_VALUE;
1127         /* We set the current DTS to an unspecified origin. */
1128         st->cur_dts     = AV_NOPTS_VALUE;
1129
1130         st->probe_packets = MAX_PROBE_PACKETS;
1131
1132         for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1133             st->pts_buffer[j] = AV_NOPTS_VALUE;
1134     }
1135 }
1136
1137 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1138 {
1139     int i;
1140
1141     for (i = 0; i < s->nb_streams; i++) {
1142         AVStream *st = s->streams[i];
1143
1144         st->cur_dts =
1145             av_rescale(timestamp,
1146                        st->time_base.den * (int64_t) ref_st->time_base.num,
1147                        st->time_base.num * (int64_t) ref_st->time_base.den);
1148     }
1149 }
1150
1151 void ff_reduce_index(AVFormatContext *s, int stream_index)
1152 {
1153     AVStream *st             = s->streams[stream_index];
1154     unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1155
1156     if ((unsigned) st->nb_index_entries >= max_entries) {
1157         int i;
1158         for (i = 0; 2 * i < st->nb_index_entries; i++)
1159             st->index_entries[i] = st->index_entries[2 * i];
1160         st->nb_index_entries = i;
1161     }
1162 }
1163
1164 int ff_add_index_entry(AVIndexEntry **index_entries,
1165                        int *nb_index_entries,
1166                        unsigned int *index_entries_allocated_size,
1167                        int64_t pos, int64_t timestamp,
1168                        int size, int distance, int flags)
1169 {
1170     AVIndexEntry *entries, *ie;
1171     int index;
1172
1173     if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1174         return -1;
1175
1176     entries = av_fast_realloc(*index_entries,
1177                               index_entries_allocated_size,
1178                               (*nb_index_entries + 1) *
1179                               sizeof(AVIndexEntry));
1180     if (!entries)
1181         return -1;
1182
1183     *index_entries = entries;
1184
1185     index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1186                                       timestamp, AVSEEK_FLAG_ANY);
1187
1188     if (index < 0) {
1189         index = (*nb_index_entries)++;
1190         ie    = &entries[index];
1191         assert(index == 0 || ie[-1].timestamp < timestamp);
1192     } else {
1193         ie = &entries[index];
1194         if (ie->timestamp != timestamp) {
1195             if (ie->timestamp <= timestamp)
1196                 return -1;
1197             memmove(entries + index + 1, entries + index,
1198                     sizeof(AVIndexEntry) * (*nb_index_entries - index));
1199             (*nb_index_entries)++;
1200         } else if (ie->pos == pos && distance < ie->min_distance)
1201             // do not reduce the distance
1202             distance = ie->min_distance;
1203     }
1204
1205     ie->pos          = pos;
1206     ie->timestamp    = timestamp;
1207     ie->min_distance = distance;
1208     ie->size         = size;
1209     ie->flags        = flags;
1210
1211     return index;
1212 }
1213
1214 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1215                        int size, int distance, int flags)
1216 {
1217     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1218                               &st->index_entries_allocated_size, pos,
1219                               timestamp, size, distance, flags);
1220 }
1221
1222 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1223                               int64_t wanted_timestamp, int flags)
1224 {
1225     int a, b, m;
1226     int64_t timestamp;
1227
1228     a = -1;
1229     b = nb_entries;
1230
1231     // Optimize appending index entries at the end.
1232     if (b && entries[b - 1].timestamp < wanted_timestamp)
1233         a = b - 1;
1234
1235     while (b - a > 1) {
1236         m         = (a + b) >> 1;
1237         timestamp = entries[m].timestamp;
1238         if (timestamp >= wanted_timestamp)
1239             b = m;
1240         if (timestamp <= wanted_timestamp)
1241             a = m;
1242     }
1243     m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1244
1245     if (!(flags & AVSEEK_FLAG_ANY))
1246         while (m >= 0 && m < nb_entries &&
1247                !(entries[m].flags & AVINDEX_KEYFRAME))
1248             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1249
1250     if (m == nb_entries)
1251         return -1;
1252     return m;
1253 }
1254
1255 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1256 {
1257     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1258                                      wanted_timestamp, flags);
1259 }
1260
1261 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1262                          int64_t target_ts, int flags)
1263 {
1264     AVInputFormat *avif = s->iformat;
1265     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1266     int64_t ts_min, ts_max, ts;
1267     int index;
1268     int64_t ret;
1269     AVStream *st;
1270
1271     if (stream_index < 0)
1272         return -1;
1273
1274     av_log(s, AV_LOG_TRACE, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1275
1276     ts_max =
1277     ts_min = AV_NOPTS_VALUE;
1278     pos_limit = -1; // GCC falsely says it may be uninitialized.
1279
1280     st = s->streams[stream_index];
1281     if (st->index_entries) {
1282         AVIndexEntry *e;
1283
1284         /* FIXME: Whole function must be checked for non-keyframe entries in
1285          * index case, especially read_timestamp(). */
1286         index = av_index_search_timestamp(st, target_ts,
1287                                           flags | AVSEEK_FLAG_BACKWARD);
1288         index = FFMAX(index, 0);
1289         e     = &st->index_entries[index];
1290
1291         if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1292             pos_min = e->pos;
1293             ts_min  = e->timestamp;
1294             av_log(s, AV_LOG_TRACE, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1295                     pos_min, ts_min);
1296         } else {
1297             assert(index == 0);
1298         }
1299
1300         index = av_index_search_timestamp(st, target_ts,
1301                                           flags & ~AVSEEK_FLAG_BACKWARD);
1302         assert(index < st->nb_index_entries);
1303         if (index >= 0) {
1304             e = &st->index_entries[index];
1305             assert(e->timestamp >= target_ts);
1306             pos_max   = e->pos;
1307             ts_max    = e->timestamp;
1308             pos_limit = pos_max - e->min_distance;
1309             av_log(s, AV_LOG_TRACE, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1310                     " dts_max=%"PRId64"\n", pos_max, pos_limit, ts_max);
1311         }
1312     }
1313
1314     pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1315                         ts_min, ts_max, flags, &ts, avif->read_timestamp);
1316     if (pos < 0)
1317         return -1;
1318
1319     /* do the seek */
1320     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1321         return ret;
1322
1323     ff_update_cur_dts(s, st, ts);
1324
1325     return 0;
1326 }
1327
1328 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1329                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1330                       int64_t ts_min, int64_t ts_max,
1331                       int flags, int64_t *ts_ret,
1332                       int64_t (*read_timestamp)(struct AVFormatContext *, int,
1333                                                 int64_t *, int64_t))
1334 {
1335     int64_t pos, ts;
1336     int64_t start_pos, filesize;
1337     int no_change;
1338
1339     av_log(s, AV_LOG_TRACE, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1340
1341     if (ts_min == AV_NOPTS_VALUE) {
1342         pos_min = s->internal->data_offset;
1343         ts_min  = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1344         if (ts_min == AV_NOPTS_VALUE)
1345             return -1;
1346     }
1347
1348     if (ts_max == AV_NOPTS_VALUE) {
1349         int step = 1024;
1350         filesize = avio_size(s->pb);
1351         pos_max  = filesize - 1;
1352         do {
1353             pos_max -= step;
1354             ts_max   = read_timestamp(s, stream_index, &pos_max,
1355                                       pos_max + step);
1356             step    += step;
1357         } while (ts_max == AV_NOPTS_VALUE && pos_max >= step);
1358         if (ts_max == AV_NOPTS_VALUE)
1359             return -1;
1360
1361         for (;;) {
1362             int64_t tmp_pos = pos_max + 1;
1363             int64_t tmp_ts  = read_timestamp(s, stream_index,
1364                                              &tmp_pos, INT64_MAX);
1365             if (tmp_ts == AV_NOPTS_VALUE)
1366                 break;
1367             ts_max  = tmp_ts;
1368             pos_max = tmp_pos;
1369             if (tmp_pos >= filesize)
1370                 break;
1371         }
1372         pos_limit = pos_max;
1373     }
1374
1375     if (ts_min > ts_max)
1376         return -1;
1377     else if (ts_min == ts_max)
1378         pos_limit = pos_min;
1379
1380     no_change = 0;
1381     while (pos_min < pos_limit) {
1382         av_log(s, AV_LOG_TRACE, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64
1383                 " dts_max=%"PRId64"\n", pos_min, pos_max, ts_min, ts_max);
1384         assert(pos_limit <= pos_max);
1385
1386         if (no_change == 0) {
1387             int64_t approximate_keyframe_distance = pos_max - pos_limit;
1388             // interpolate position (better than dichotomy)
1389             pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1390                              ts_max - ts_min) +
1391                   pos_min - approximate_keyframe_distance;
1392         } else if (no_change == 1) {
1393             // bisection if interpolation did not change min / max pos last time
1394             pos = (pos_min + pos_limit) >> 1;
1395         } else {
1396             /* linear search if bisection failed, can only happen if there
1397              * are very few or no keyframes between min/max */
1398             pos = pos_min;
1399         }
1400         if (pos <= pos_min)
1401             pos = pos_min + 1;
1402         else if (pos > pos_limit)
1403             pos = pos_limit;
1404         start_pos = pos;
1405
1406         // May pass pos_limit instead of -1.
1407         ts = read_timestamp(s, stream_index, &pos, INT64_MAX);
1408         if (pos == pos_max)
1409             no_change++;
1410         else
1411             no_change = 0;
1412         av_log(s, AV_LOG_TRACE, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64
1413                 " target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1414                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1415                 pos_limit, start_pos, no_change);
1416         if (ts == AV_NOPTS_VALUE) {
1417             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1418             return -1;
1419         }
1420         assert(ts != AV_NOPTS_VALUE);
1421         if (target_ts <= ts) {
1422             pos_limit = start_pos - 1;
1423             pos_max   = pos;
1424             ts_max    = ts;
1425         }
1426         if (target_ts >= ts) {
1427             pos_min = pos;
1428             ts_min  = ts;
1429         }
1430     }
1431
1432     pos     = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1433     ts      = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min  : ts_max;
1434     pos_min = pos;
1435     ts_min  = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1436     pos_min++;
1437     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1438     av_log(s, AV_LOG_TRACE, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1439             pos, ts_min, target_ts, ts_max);
1440     *ts_ret = ts;
1441     return pos;
1442 }
1443
1444 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1445                            int64_t pos, int flags)
1446 {
1447     int64_t pos_min, pos_max;
1448
1449     pos_min = s->internal->data_offset;
1450     pos_max = avio_size(s->pb) - 1;
1451
1452     if (pos < pos_min)
1453         pos = pos_min;
1454     else if (pos > pos_max)
1455         pos = pos_max;
1456
1457     avio_seek(s->pb, pos, SEEK_SET);
1458
1459     return 0;
1460 }
1461
1462 static int seek_frame_generic(AVFormatContext *s, int stream_index,
1463                               int64_t timestamp, int flags)
1464 {
1465     int index;
1466     int64_t ret;
1467     AVStream *st;
1468     AVIndexEntry *ie;
1469
1470     st = s->streams[stream_index];
1471
1472     index = av_index_search_timestamp(st, timestamp, flags);
1473
1474     if (index < 0 && st->nb_index_entries &&
1475         timestamp < st->index_entries[0].timestamp)
1476         return -1;
1477
1478     if (index < 0 || index == st->nb_index_entries - 1) {
1479         AVPacket pkt;
1480
1481         if (st->nb_index_entries) {
1482             assert(st->index_entries);
1483             ie = &st->index_entries[st->nb_index_entries - 1];
1484             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1485                 return ret;
1486             ff_update_cur_dts(s, st, ie->timestamp);
1487         } else {
1488             if ((ret = avio_seek(s->pb, s->internal->data_offset, SEEK_SET)) < 0)
1489                 return ret;
1490         }
1491         for (;;) {
1492             int read_status;
1493             do {
1494                 read_status = av_read_frame(s, &pkt);
1495             } while (read_status == AVERROR(EAGAIN));
1496             if (read_status < 0)
1497                 break;
1498             av_packet_unref(&pkt);
1499             if (stream_index == pkt.stream_index)
1500                 if ((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1501                     break;
1502         }
1503         index = av_index_search_timestamp(st, timestamp, flags);
1504     }
1505     if (index < 0)
1506         return -1;
1507
1508     ff_read_frame_flush(s);
1509     if (s->iformat->read_seek)
1510         if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1511             return 0;
1512     ie = &st->index_entries[index];
1513     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1514         return ret;
1515     ff_update_cur_dts(s, st, ie->timestamp);
1516
1517     return 0;
1518 }
1519
1520 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1521                                int64_t timestamp, int flags)
1522 {
1523     int ret;
1524     AVStream *st;
1525
1526     if (flags & AVSEEK_FLAG_BYTE) {
1527         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1528             return -1;
1529         ff_read_frame_flush(s);
1530         return seek_frame_byte(s, stream_index, timestamp, flags);
1531     }
1532
1533     if (stream_index < 0) {
1534         stream_index = av_find_default_stream_index(s);
1535         if (stream_index < 0)
1536             return -1;
1537
1538         st = s->streams[stream_index];
1539         /* timestamp for default must be expressed in AV_TIME_BASE units */
1540         timestamp = av_rescale(timestamp, st->time_base.den,
1541                                AV_TIME_BASE * (int64_t) st->time_base.num);
1542     }
1543
1544     /* first, we try the format specific seek */
1545     if (s->iformat->read_seek) {
1546         ff_read_frame_flush(s);
1547         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1548     } else
1549         ret = -1;
1550     if (ret >= 0)
1551         return 0;
1552
1553     if (s->iformat->read_timestamp &&
1554         !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1555         ff_read_frame_flush(s);
1556         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1557     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1558         ff_read_frame_flush(s);
1559         return seek_frame_generic(s, stream_index, timestamp, flags);
1560     } else
1561         return -1;
1562 }
1563
1564 int av_seek_frame(AVFormatContext *s, int stream_index,
1565                   int64_t timestamp, int flags)
1566 {
1567     int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1568
1569     if (ret >= 0)
1570         ret = queue_attached_pictures(s);
1571
1572     return ret;
1573 }
1574
1575 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
1576                        int64_t ts, int64_t max_ts, int flags)
1577 {
1578     if (min_ts > ts || max_ts < ts)
1579         return -1;
1580
1581     if (s->iformat->read_seek2) {
1582         int ret;
1583         ff_read_frame_flush(s);
1584         ret = s->iformat->read_seek2(s, stream_index, min_ts,
1585                                      ts, max_ts, flags);
1586
1587         if (ret >= 0)
1588             ret = queue_attached_pictures(s);
1589         return ret;
1590     }
1591
1592     if (s->iformat->read_timestamp) {
1593         // try to seek via read_timestamp()
1594     }
1595
1596     // Fall back on old API if new is not implemented but old is.
1597     // Note the old API has somewhat different semantics.
1598     if (s->iformat->read_seek || 1)
1599         return av_seek_frame(s, stream_index, ts,
1600                              flags | ((uint64_t) ts - min_ts >
1601                                       (uint64_t) max_ts - ts
1602                                       ? AVSEEK_FLAG_BACKWARD : 0));
1603
1604     // try some generic seek like seek_frame_generic() but with new ts semantics
1605 }
1606
1607 /*******************************************************/
1608
1609 /**
1610  * Return TRUE if the stream has accurate duration in any stream.
1611  *
1612  * @return TRUE if the stream has accurate duration for at least one component.
1613  */
1614 static int has_duration(AVFormatContext *ic)
1615 {
1616     int i;
1617     AVStream *st;
1618
1619     for (i = 0; i < ic->nb_streams; i++) {
1620         st = ic->streams[i];
1621         if (st->duration != AV_NOPTS_VALUE)
1622             return 1;
1623     }
1624     if (ic->duration != AV_NOPTS_VALUE)
1625         return 1;
1626     return 0;
1627 }
1628
1629 /**
1630  * Estimate the stream timings from the one of each components.
1631  *
1632  * Also computes the global bitrate if possible.
1633  */
1634 static void update_stream_timings(AVFormatContext *ic)
1635 {
1636     int64_t start_time, start_time1, end_time, end_time1;
1637     int64_t duration, duration1, filesize;
1638     int i;
1639     AVStream *st;
1640
1641     start_time = INT64_MAX;
1642     end_time   = INT64_MIN;
1643     duration   = INT64_MIN;
1644     for (i = 0; i < ic->nb_streams; i++) {
1645         st = ic->streams[i];
1646         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1647             start_time1 = av_rescale_q(st->start_time, st->time_base,
1648                                        AV_TIME_BASE_Q);
1649             start_time  = FFMIN(start_time, start_time1);
1650             if (st->duration != AV_NOPTS_VALUE) {
1651                 end_time1 = start_time1 +
1652                             av_rescale_q(st->duration, st->time_base,
1653                                          AV_TIME_BASE_Q);
1654                 end_time = FFMAX(end_time, end_time1);
1655             }
1656         }
1657         if (st->duration != AV_NOPTS_VALUE) {
1658             duration1 = av_rescale_q(st->duration, st->time_base,
1659                                      AV_TIME_BASE_Q);
1660             duration  = FFMAX(duration, duration1);
1661         }
1662     }
1663     if (start_time != INT64_MAX) {
1664         ic->start_time = start_time;
1665         if (end_time != INT64_MIN)
1666             duration = FFMAX(duration, end_time - start_time);
1667     }
1668     if (duration != INT64_MIN) {
1669         ic->duration = duration;
1670         if (ic->pb && (filesize = avio_size(ic->pb)) > 0)
1671             /* compute the bitrate */
1672             ic->bit_rate = (double) filesize * 8.0 * AV_TIME_BASE /
1673                            (double) ic->duration;
1674     }
1675 }
1676
1677 static void fill_all_stream_timings(AVFormatContext *ic)
1678 {
1679     int i;
1680     AVStream *st;
1681
1682     update_stream_timings(ic);
1683     for (i = 0; i < ic->nb_streams; i++) {
1684         st = ic->streams[i];
1685         if (st->start_time == AV_NOPTS_VALUE) {
1686             if (ic->start_time != AV_NOPTS_VALUE)
1687                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
1688                                               st->time_base);
1689             if (ic->duration != AV_NOPTS_VALUE)
1690                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
1691                                             st->time_base);
1692         }
1693     }
1694 }
1695
1696 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1697 {
1698     int64_t filesize, duration;
1699     int i;
1700     AVStream *st;
1701
1702     /* if bit_rate is already set, we believe it */
1703     if (ic->bit_rate <= 0) {
1704         int bit_rate = 0;
1705         for (i = 0; i < ic->nb_streams; i++) {
1706             st = ic->streams[i];
1707             if (st->codecpar->bit_rate > 0) {
1708                 if (INT_MAX - st->codecpar->bit_rate < bit_rate) {
1709                     bit_rate = 0;
1710                     break;
1711                 }
1712                 bit_rate += st->codecpar->bit_rate;
1713             }
1714         }
1715         ic->bit_rate = bit_rate;
1716     }
1717
1718     /* if duration is already set, we believe it */
1719     if (ic->duration == AV_NOPTS_VALUE &&
1720         ic->bit_rate != 0) {
1721         filesize = ic->pb ? avio_size(ic->pb) : 0;
1722         if (filesize > 0) {
1723             for (i = 0; i < ic->nb_streams; i++) {
1724                 st       = ic->streams[i];
1725                 duration = av_rescale(8 * filesize, st->time_base.den,
1726                                       ic->bit_rate *
1727                                       (int64_t) st->time_base.num);
1728                 if (st->duration == AV_NOPTS_VALUE)
1729                     st->duration = duration;
1730             }
1731         }
1732     }
1733 }
1734
1735 #define DURATION_MAX_READ_SIZE 250000
1736 #define DURATION_MAX_RETRY 3
1737
1738 /* only usable for MPEG-PS streams */
1739 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1740 {
1741     AVPacket pkt1, *pkt = &pkt1;
1742     AVStream *st;
1743     int read_size, i, ret;
1744     int64_t end_time;
1745     int64_t filesize, offset, duration;
1746     int retry = 0;
1747
1748     /* flush packet queue */
1749     flush_packet_queue(ic);
1750
1751     for (i = 0; i < ic->nb_streams; i++) {
1752         st = ic->streams[i];
1753         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1754             av_log(ic, AV_LOG_WARNING,
1755                    "start time is not set in estimate_timings_from_pts\n");
1756
1757         if (st->parser) {
1758             av_parser_close(st->parser);
1759             st->parser = NULL;
1760         }
1761     }
1762
1763     /* estimate the end time (duration) */
1764     /* XXX: may need to support wrapping */
1765     filesize = ic->pb ? avio_size(ic->pb) : 0;
1766     end_time = AV_NOPTS_VALUE;
1767     do {
1768         offset = filesize - (DURATION_MAX_READ_SIZE << retry);
1769         if (offset < 0)
1770             offset = 0;
1771
1772         avio_seek(ic->pb, offset, SEEK_SET);
1773         read_size = 0;
1774         for (;;) {
1775             if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
1776                 break;
1777
1778             do {
1779                 ret = ff_read_packet(ic, pkt);
1780             } while (ret == AVERROR(EAGAIN));
1781             if (ret != 0)
1782                 break;
1783             read_size += pkt->size;
1784             st         = ic->streams[pkt->stream_index];
1785             if (pkt->pts != AV_NOPTS_VALUE &&
1786                 (st->start_time != AV_NOPTS_VALUE ||
1787                  st->first_dts  != AV_NOPTS_VALUE)) {
1788                 duration = end_time = pkt->pts;
1789                 if (st->start_time != AV_NOPTS_VALUE)
1790                     duration -= st->start_time;
1791                 else
1792                     duration -= st->first_dts;
1793                 if (duration < 0)
1794                     duration += 1LL << st->pts_wrap_bits;
1795                 if (duration > 0) {
1796                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1797                         st->duration = duration;
1798                 }
1799             }
1800             av_packet_unref(pkt);
1801         }
1802     } while (end_time == AV_NOPTS_VALUE &&
1803              filesize > (DURATION_MAX_READ_SIZE << retry) &&
1804              ++retry <= DURATION_MAX_RETRY);
1805
1806     fill_all_stream_timings(ic);
1807
1808     avio_seek(ic->pb, old_offset, SEEK_SET);
1809     for (i = 0; i < ic->nb_streams; i++) {
1810         st              = ic->streams[i];
1811         st->cur_dts     = st->first_dts;
1812         st->last_IP_pts = AV_NOPTS_VALUE;
1813     }
1814 }
1815
1816 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1817 {
1818     int64_t file_size;
1819
1820     /* get the file size, if possible */
1821     if (ic->iformat->flags & AVFMT_NOFILE) {
1822         file_size = 0;
1823     } else {
1824         file_size = avio_size(ic->pb);
1825         file_size = FFMAX(0, file_size);
1826     }
1827
1828     if ((!strcmp(ic->iformat->name, "mpeg") ||
1829          !strcmp(ic->iformat->name, "mpegts")) &&
1830         file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
1831         /* get accurate estimate from the PTSes */
1832         estimate_timings_from_pts(ic, old_offset);
1833     } else if (has_duration(ic)) {
1834         /* at least one component has timings - we use them for all
1835          * the components */
1836         fill_all_stream_timings(ic);
1837     } else {
1838         av_log(ic, AV_LOG_WARNING,
1839                "Estimating duration from bitrate, this may be inaccurate\n");
1840         /* less precise: use bitrate info */
1841         estimate_timings_from_bit_rate(ic);
1842     }
1843     update_stream_timings(ic);
1844
1845     {
1846         int i;
1847         AVStream av_unused *st;
1848         for (i = 0; i < ic->nb_streams; i++) {
1849             st = ic->streams[i];
1850             av_log(ic, AV_LOG_TRACE, "%d: start_time: %0.3f duration: %0.3f\n", i,
1851                     (double) st->start_time / AV_TIME_BASE,
1852                     (double) st->duration   / AV_TIME_BASE);
1853         }
1854         av_log(ic, AV_LOG_TRACE,
1855                 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1856                 (double) ic->start_time / AV_TIME_BASE,
1857                 (double) ic->duration   / AV_TIME_BASE,
1858                 ic->bit_rate / 1000);
1859     }
1860 }
1861
1862 static int has_codec_parameters(AVStream *st)
1863 {
1864     AVCodecContext *avctx = st->internal->avctx;
1865     int val;
1866
1867     switch (avctx->codec_type) {
1868     case AVMEDIA_TYPE_AUDIO:
1869         val = avctx->sample_rate && avctx->channels;
1870         if (st->info->found_decoder >= 0 &&
1871             avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
1872             return 0;
1873         break;
1874     case AVMEDIA_TYPE_VIDEO:
1875         val = avctx->width;
1876         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
1877             return 0;
1878         break;
1879     default:
1880         val = 1;
1881         break;
1882     }
1883     return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
1884 }
1885
1886 static int has_decode_delay_been_guessed(AVStream *st)
1887 {
1888     return st->internal->avctx->codec_id != AV_CODEC_ID_H264 ||
1889            st->info->nb_decoded_frames >= 6;
1890 }
1891
1892 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
1893 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
1894                             AVDictionary **options)
1895 {
1896     AVCodecContext *avctx = st->internal->avctx;
1897     const AVCodec *codec;
1898     int got_picture = 1, ret = 0;
1899     AVFrame *frame = av_frame_alloc();
1900     AVPacket pkt = *avpkt;
1901
1902     if (!frame)
1903         return AVERROR(ENOMEM);
1904
1905     if (!avcodec_is_open(avctx) && !st->info->found_decoder) {
1906         AVDictionary *thread_opt = NULL;
1907
1908 #if FF_API_LAVF_AVCTX
1909 FF_DISABLE_DEPRECATION_WARNINGS
1910         codec = st->codec->codec ? st->codec->codec
1911                                  : avcodec_find_decoder(st->codecpar->codec_id);
1912 FF_ENABLE_DEPRECATION_WARNINGS
1913 #else
1914         codec = avcodec_find_decoder(st->codecpar->codec_id);
1915 #endif
1916
1917         if (!codec) {
1918             st->info->found_decoder = -1;
1919             ret                     = -1;
1920             goto fail;
1921         }
1922
1923         /* Force thread count to 1 since the H.264 decoder will not extract
1924          * SPS and PPS to extradata during multi-threaded decoding. */
1925         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
1926         ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
1927         if (!options)
1928             av_dict_free(&thread_opt);
1929         if (ret < 0) {
1930             st->info->found_decoder = -1;
1931             goto fail;
1932         }
1933         st->info->found_decoder = 1;
1934     } else if (!st->info->found_decoder)
1935         st->info->found_decoder = 1;
1936
1937     if (st->info->found_decoder < 0) {
1938         ret = -1;
1939         goto fail;
1940     }
1941
1942     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
1943            ret >= 0 &&
1944            (!has_codec_parameters(st) || !has_decode_delay_been_guessed(st) ||
1945             (!st->codec_info_nb_frames &&
1946              (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
1947         got_picture = 0;
1948         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
1949             avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1950             ret = avcodec_send_packet(avctx, &pkt);
1951             if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1952                 break;
1953             if (ret >= 0)
1954                 pkt.size = 0;
1955             ret = avcodec_receive_frame(avctx, frame);
1956             if (ret >= 0)
1957                 got_picture = 1;
1958             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
1959                 ret = 0;
1960         }
1961         if (ret >= 0) {
1962             if (got_picture)
1963                 st->info->nb_decoded_frames++;
1964             ret       = got_picture;
1965         }
1966     }
1967
1968 fail:
1969     av_frame_free(&frame);
1970     return ret;
1971 }
1972
1973 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
1974 {
1975     while (tags->id != AV_CODEC_ID_NONE) {
1976         if (tags->id == id)
1977             return tags->tag;
1978         tags++;
1979     }
1980     return 0;
1981 }
1982
1983 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1984 {
1985     int i;
1986     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
1987         if (tag == tags[i].tag)
1988             return tags[i].id;
1989     for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
1990         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
1991             return tags[i].id;
1992     return AV_CODEC_ID_NONE;
1993 }
1994
1995 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
1996 {
1997     if (flt) {
1998         switch (bps) {
1999         case 32:
2000             return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2001         case 64:
2002             return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2003         default:
2004             return AV_CODEC_ID_NONE;
2005         }
2006     } else {
2007         bps >>= 3;
2008         if (sflags & (1 << (bps - 1))) {
2009             switch (bps) {
2010             case 1:
2011                 return AV_CODEC_ID_PCM_S8;
2012             case 2:
2013                 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2014             case 3:
2015                 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2016             case 4:
2017                 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2018             default:
2019                 return AV_CODEC_ID_NONE;
2020             }
2021         } else {
2022             switch (bps) {
2023             case 1:
2024                 return AV_CODEC_ID_PCM_U8;
2025             case 2:
2026                 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2027             case 3:
2028                 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2029             case 4:
2030                 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2031             default:
2032                 return AV_CODEC_ID_NONE;
2033             }
2034         }
2035     }
2036 }
2037
2038 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2039 {
2040     int i;
2041     for (i = 0; tags && tags[i]; i++) {
2042         int tag = ff_codec_get_tag(tags[i], id);
2043         if (tag)
2044             return tag;
2045     }
2046     return 0;
2047 }
2048
2049 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2050 {
2051     int i;
2052     for (i = 0; tags && tags[i]; i++) {
2053         enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2054         if (id != AV_CODEC_ID_NONE)
2055             return id;
2056     }
2057     return AV_CODEC_ID_NONE;
2058 }
2059
2060 static void compute_chapters_end(AVFormatContext *s)
2061 {
2062     unsigned int i, j;
2063     int64_t max_time = s->duration +
2064                        ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2065
2066     for (i = 0; i < s->nb_chapters; i++)
2067         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2068             AVChapter *ch = s->chapters[i];
2069             int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2070                                                   ch->time_base)
2071                                    : INT64_MAX;
2072
2073             for (j = 0; j < s->nb_chapters; j++) {
2074                 AVChapter *ch1     = s->chapters[j];
2075                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2076                                                   ch->time_base);
2077                 if (j != i && next_start > ch->start && next_start < end)
2078                     end = next_start;
2079             }
2080             ch->end = (end == INT64_MAX) ? ch->start : end;
2081         }
2082 }
2083
2084 static int get_std_framerate(int i)
2085 {
2086     if (i < 60 * 12)
2087         return (i + 1) * 1001;
2088     else
2089         return ((const int[]) { 24, 30, 60, 12, 15 })[i - 60 * 12] * 1000 * 12;
2090 }
2091
2092 static int extract_extradata_init(AVStream *st)
2093 {
2094     AVStreamInternal *i = st->internal;
2095     const AVBitStreamFilter *f;
2096     int ret;
2097
2098     f = av_bsf_get_by_name("extract_extradata");
2099     if (!f)
2100         goto finish;
2101
2102     /* check that the codec id is supported */
2103     if (f->codec_ids) {
2104         const enum AVCodecID *ids;
2105         for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
2106             if (*ids == st->codecpar->codec_id)
2107                 break;
2108         if (*ids == AV_CODEC_ID_NONE)
2109             goto finish;
2110     }
2111
2112     i->extract_extradata.pkt = av_packet_alloc();
2113     if (!i->extract_extradata.pkt)
2114         return AVERROR(ENOMEM);
2115
2116     ret = av_bsf_alloc(f, &i->extract_extradata.bsf);
2117     if (ret < 0)
2118         goto fail;
2119
2120     ret = avcodec_parameters_copy(i->extract_extradata.bsf->par_in,
2121                                   st->codecpar);
2122     if (ret < 0)
2123         goto fail;
2124
2125     i->extract_extradata.bsf->time_base_in = st->time_base;
2126
2127     /* if init fails here, we assume extracting extradata is just not
2128      * supported for this codec, so we return success */
2129     ret = av_bsf_init(i->extract_extradata.bsf);
2130     if (ret < 0) {
2131         av_bsf_free(&i->extract_extradata.bsf);
2132         ret = 0;
2133     }
2134
2135 finish:
2136     i->extract_extradata.inited = 1;
2137
2138     return 0;
2139 fail:
2140     av_bsf_free(&i->extract_extradata.bsf);
2141     av_packet_free(&i->extract_extradata.pkt);
2142     return ret;
2143 }
2144
2145 static int extract_extradata(AVStream *st, AVPacket *pkt)
2146 {
2147     AVStreamInternal *i = st->internal;
2148     AVPacket *pkt_ref;
2149     int ret;
2150
2151     if (!i->extract_extradata.inited) {
2152         ret = extract_extradata_init(st);
2153         if (ret < 0)
2154             return ret;
2155     }
2156
2157     if (i->extract_extradata.inited && !i->extract_extradata.bsf)
2158         return 0;
2159
2160     pkt_ref = i->extract_extradata.pkt;
2161     ret = av_packet_ref(pkt_ref, pkt);
2162     if (ret < 0)
2163         return ret;
2164
2165     ret = av_bsf_send_packet(i->extract_extradata.bsf, pkt_ref);
2166     if (ret < 0) {
2167         av_packet_unref(pkt_ref);
2168         return ret;
2169     }
2170
2171     while (ret >= 0 && !i->avctx->extradata) {
2172         int extradata_size;
2173         uint8_t *extradata;
2174
2175         ret = av_bsf_receive_packet(i->extract_extradata.bsf, pkt_ref);
2176         if (ret < 0) {
2177             if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2178                 return ret;
2179             continue;
2180         }
2181
2182         extradata = av_packet_get_side_data(pkt_ref, AV_PKT_DATA_NEW_EXTRADATA,
2183                                             &extradata_size);
2184
2185         if (extradata) {
2186             i->avctx->extradata = av_mallocz(extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
2187             if (!i->avctx->extradata) {
2188                 av_packet_unref(pkt_ref);
2189                 return AVERROR(ENOMEM);
2190             }
2191             memcpy(i->avctx->extradata, extradata, extradata_size);
2192             i->avctx->extradata_size = extradata_size;
2193         }
2194         av_packet_unref(pkt_ref);
2195     }
2196
2197     return 0;
2198 }
2199
2200 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2201 {
2202     int i, count, ret, read_size, j;
2203     AVStream *st;
2204     AVCodecContext *avctx;
2205     AVPacket pkt1, *pkt;
2206     int64_t old_offset  = avio_tell(ic->pb);
2207     // new streams might appear, no options for those
2208     int orig_nb_streams = ic->nb_streams;
2209
2210     for (i = 0; i < ic->nb_streams; i++) {
2211         const AVCodec *codec;
2212         AVDictionary *thread_opt = NULL;
2213         st = ic->streams[i];
2214         avctx = st->internal->avctx;
2215
2216         // only for the split stuff
2217         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2218             st->parser = av_parser_init(st->codecpar->codec_id);
2219             if (st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser)
2220                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2221         }
2222
2223         /* check if the caller has overridden the codec id */
2224 #if FF_API_LAVF_AVCTX
2225 FF_DISABLE_DEPRECATION_WARNINGS
2226         if (st->codec->codec_id != st->internal->orig_codec_id) {
2227             st->codecpar->codec_id   = st->codec->codec_id;
2228             st->codecpar->codec_type = st->codec->codec_type;
2229             st->internal->orig_codec_id = st->codec->codec_id;
2230         }
2231 FF_ENABLE_DEPRECATION_WARNINGS
2232 #endif
2233         if (st->codecpar->codec_id != st->internal->orig_codec_id)
2234             st->internal->orig_codec_id = st->codecpar->codec_id;
2235
2236         ret = avcodec_parameters_to_context(avctx, st->codecpar);
2237         if (ret < 0)
2238             goto find_stream_info_err;
2239         if (st->codecpar->codec_id != AV_CODEC_ID_PROBE &&
2240             st->codecpar->codec_id != AV_CODEC_ID_NONE)
2241             st->internal->avctx_inited = 1;
2242
2243 #if FF_API_LAVF_AVCTX
2244 FF_DISABLE_DEPRECATION_WARNINGS
2245         codec = st->codec->codec ? st->codec->codec
2246                                  : avcodec_find_decoder(st->codecpar->codec_id);
2247 FF_ENABLE_DEPRECATION_WARNINGS
2248 #else
2249         codec = avcodec_find_decoder(st->codecpar->codec_id);
2250 #endif
2251
2252         /* Force thread count to 1 since the H.264 decoder will not extract
2253          * SPS and PPS to extradata during multi-threaded decoding. */
2254         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2255
2256         /* Ensure that subtitle_header is properly set. */
2257         if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE
2258             && codec && !avctx->codec)
2259             avcodec_open2(avctx, codec,
2260                           options ? &options[i] : &thread_opt);
2261
2262         // Try to just open decoders, in case this is enough to get parameters.
2263         if (!has_codec_parameters(st)) {
2264             if (codec && !avctx->codec)
2265                 avcodec_open2(avctx, codec,
2266                               options ? &options[i] : &thread_opt);
2267         }
2268         if (!options)
2269             av_dict_free(&thread_opt);
2270     }
2271
2272     for (i = 0; i < ic->nb_streams; i++) {
2273         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2274         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2275     }
2276
2277     count     = 0;
2278     read_size = 0;
2279     for (;;) {
2280         if (ff_check_interrupt(&ic->interrupt_callback)) {
2281             ret = AVERROR_EXIT;
2282             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2283             break;
2284         }
2285
2286         /* check if one codec still needs to be handled */
2287         for (i = 0; i < ic->nb_streams; i++) {
2288             int fps_analyze_framecount = 20;
2289
2290             st = ic->streams[i];
2291             if (!has_codec_parameters(st))
2292                 break;
2293             /* If the timebase is coarse (like the usual millisecond precision
2294              * of mkv), we need to analyze more frames to reliably arrive at
2295              * the correct fps. */
2296             if (av_q2d(st->time_base) > 0.0005)
2297                 fps_analyze_framecount *= 2;
2298             if (ic->fps_probe_size >= 0)
2299                 fps_analyze_framecount = ic->fps_probe_size;
2300             /* variable fps and no guess at the real fps */
2301             if (!st->avg_frame_rate.num &&
2302                 st->codec_info_nb_frames < fps_analyze_framecount &&
2303                 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2304                 break;
2305             if (!st->codecpar->extradata &&
2306                 !st->internal->avctx->extradata &&
2307                 (!st->internal->extract_extradata.inited ||
2308                  st->internal->extract_extradata.bsf))
2309                 break;
2310             if (st->first_dts == AV_NOPTS_VALUE &&
2311                 st->codec_info_nb_frames < ic->max_ts_probe &&
2312                 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2313                  st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
2314                 break;
2315         }
2316         if (i == ic->nb_streams) {
2317             /* NOTE: If the format has no header, then we need to read some
2318              * packets to get most of the streams, so we cannot stop here. */
2319             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2320                 /* If we found the info for all the codecs, we can stop. */
2321                 ret = count;
2322                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2323                 break;
2324             }
2325         }
2326         /* We did not get all the codec info, but we read too much data. */
2327         if (read_size >= ic->probesize) {
2328             ret = count;
2329             av_log(ic, AV_LOG_DEBUG,
2330                    "Probe buffer size limit %d reached\n", ic->probesize);
2331             break;
2332         }
2333
2334         /* NOTE: A new stream can be added there if no header in file
2335          * (AVFMTCTX_NOHEADER). */
2336         ret = read_frame_internal(ic, &pkt1);
2337         if (ret == AVERROR(EAGAIN))
2338             continue;
2339
2340         if (ret < 0) {
2341             /* EOF or error*/
2342             AVPacket empty_pkt = { 0 };
2343             int err = 0;
2344             av_init_packet(&empty_pkt);
2345
2346             /* We could not have all the codec parameters before EOF. */
2347             ret = -1;
2348             for (i = 0; i < ic->nb_streams; i++) {
2349                 st = ic->streams[i];
2350
2351                 /* flush the decoders */
2352                 if (st->info->found_decoder == 1) {
2353                     do {
2354                         err = try_decode_frame(ic, st, &empty_pkt,
2355                                                (options && i < orig_nb_streams)
2356                                                ? &options[i] : NULL);
2357                     } while (err > 0 && !has_codec_parameters(st));
2358                 }
2359
2360                 if (err < 0) {
2361                     av_log(ic, AV_LOG_WARNING,
2362                            "decoding for stream %d failed\n", st->index);
2363                 } else if (!has_codec_parameters(st)) {
2364                     char buf[256];
2365                     avcodec_string(buf, sizeof(buf), st->internal->avctx, 0);
2366                     av_log(ic, AV_LOG_WARNING,
2367                            "Could not find codec parameters (%s)\n", buf);
2368                 } else {
2369                     ret = 0;
2370                 }
2371             }
2372             break;
2373         }
2374
2375         pkt = &pkt1;
2376
2377         if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
2378             ret = add_to_pktbuf(&ic->internal->packet_buffer, pkt,
2379                                 &ic->internal->packet_buffer_end, 0);
2380             if (ret < 0)
2381                 goto find_stream_info_err;
2382         }
2383
2384         read_size += pkt->size;
2385
2386         st = ic->streams[pkt->stream_index];
2387         avctx = st->internal->avctx;
2388         if (!st->internal->avctx_inited) {
2389             ret = avcodec_parameters_to_context(avctx, st->codecpar);
2390             if (ret < 0)
2391                 goto find_stream_info_err;
2392             st->internal->avctx_inited = 1;
2393         }
2394
2395         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2396             /* check for non-increasing dts */
2397             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2398                 st->info->fps_last_dts >= pkt->dts) {
2399                 av_log(ic, AV_LOG_WARNING,
2400                        "Non-increasing DTS in stream %d: packet %d with DTS "
2401                        "%"PRId64", packet %d with DTS %"PRId64"\n",
2402                        st->index, st->info->fps_last_dts_idx,
2403                        st->info->fps_last_dts, st->codec_info_nb_frames,
2404                        pkt->dts);
2405                 st->info->fps_first_dts =
2406                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
2407             }
2408             /* Check for a discontinuity in dts. If the difference in dts
2409              * is more than 1000 times the average packet duration in the
2410              * sequence, we treat it as a discontinuity. */
2411             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2412                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2413                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2414                 (st->info->fps_last_dts     - st->info->fps_first_dts) /
2415                 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2416                 av_log(ic, AV_LOG_WARNING,
2417                        "DTS discontinuity in stream %d: packet %d with DTS "
2418                        "%"PRId64", packet %d with DTS %"PRId64"\n",
2419                        st->index, st->info->fps_last_dts_idx,
2420                        st->info->fps_last_dts, st->codec_info_nb_frames,
2421                        pkt->dts);
2422                 st->info->fps_first_dts =
2423                 st->info->fps_last_dts  = AV_NOPTS_VALUE;
2424             }
2425
2426             /* update stored dts values */
2427             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2428                 st->info->fps_first_dts     = pkt->dts;
2429                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2430             }
2431             st->info->fps_last_dts     = pkt->dts;
2432             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2433
2434             /* check max_analyze_duration */
2435             if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
2436                              AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2437                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached\n",
2438                        ic->max_analyze_duration);
2439                 if (ic->flags & AVFMT_FLAG_NOBUFFER)
2440                     av_packet_unref(pkt);
2441                 break;
2442             }
2443         }
2444         if (!st->internal->avctx->extradata) {
2445             ret = extract_extradata(st, pkt);
2446             if (ret < 0)
2447                 goto find_stream_info_err;
2448         }
2449
2450         /* If still no information, we try to open the codec and to
2451          * decompress the frame. We try to avoid that in most cases as
2452          * it takes longer and uses more memory. For MPEG-4, we need to
2453          * decompress for QuickTime.
2454          *
2455          * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2456          * least one frame of codec data, this makes sure the codec initializes
2457          * the channel configuration and does not only trust the values from
2458          * the container. */
2459         try_decode_frame(ic, st, pkt,
2460                          (options && i < orig_nb_streams) ? &options[i] : NULL);
2461
2462         if (ic->flags & AVFMT_FLAG_NOBUFFER)
2463             av_packet_unref(pkt);
2464
2465         st->codec_info_nb_frames++;
2466         count++;
2467     }
2468
2469     for (i = 0; i < ic->nb_streams; i++) {
2470         st = ic->streams[i];
2471         avctx = st->internal->avctx;
2472         if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2473             /* estimate average framerate if not set by demuxer */
2474             if (!st->avg_frame_rate.num &&
2475                 st->info->fps_last_dts != st->info->fps_first_dts) {
2476                 int64_t delta_dts = st->info->fps_last_dts -
2477                                     st->info->fps_first_dts;
2478                 int delta_packets = st->info->fps_last_dts_idx -
2479                                     st->info->fps_first_dts_idx;
2480                 int best_fps      = 0;
2481                 double best_error = 0.01;
2482
2483                 if (delta_dts     >= INT64_MAX / st->time_base.num ||
2484                     delta_packets >= INT64_MAX / st->time_base.den ||
2485                     delta_dts < 0)
2486                     continue;
2487                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2488                           delta_packets * (int64_t) st->time_base.den,
2489                           delta_dts * (int64_t) st->time_base.num, 60000);
2490
2491                 /* Round guessed framerate to a "standard" framerate if it's
2492                  * within 1% of the original estimate. */
2493                 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
2494                     AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
2495                     double error       = fabs(av_q2d(st->avg_frame_rate) /
2496                                               av_q2d(std_fps) - 1);
2497
2498                     if (error < best_error) {
2499                         best_error = error;
2500                         best_fps   = std_fps.num;
2501                     }
2502                 }
2503                 if (best_fps)
2504                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2505                               best_fps, 12 * 1001, INT_MAX);
2506             }
2507         } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2508             if (!avctx->bits_per_coded_sample)
2509                 avctx->bits_per_coded_sample =
2510                     av_get_bits_per_sample(avctx->codec_id);
2511             // set stream disposition based on audio service type
2512             switch (avctx->audio_service_type) {
2513             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2514                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
2515                 break;
2516             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2517                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
2518                 break;
2519             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2520                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
2521                 break;
2522             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2523                 st->disposition = AV_DISPOSITION_COMMENT;
2524                 break;
2525             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2526                 st->disposition = AV_DISPOSITION_KARAOKE;
2527                 break;
2528             }
2529         }
2530     }
2531
2532     compute_chapters_end(ic);
2533
2534     /* update the stream parameters from the internal codec contexts */
2535     for (i = 0; i < ic->nb_streams; i++) {
2536         st = ic->streams[i];
2537         if (!st->internal->avctx_inited)
2538             continue;
2539
2540         ret = avcodec_parameters_from_context(st->codecpar, st->internal->avctx);
2541         if (ret < 0)
2542             goto find_stream_info_err;
2543
2544 #if FF_API_LAVF_AVCTX
2545 FF_DISABLE_DEPRECATION_WARNINGS
2546         ret = avcodec_parameters_to_context(st->codec, st->codecpar);
2547         if (ret < 0)
2548             goto find_stream_info_err;
2549
2550         if (st->internal->avctx->subtitle_header) {
2551             st->codec->subtitle_header = av_malloc(st->internal->avctx->subtitle_header_size);
2552             if (!st->codec->subtitle_header)
2553                 goto find_stream_info_err;
2554             st->codec->subtitle_header_size = st->internal->avctx->subtitle_header_size;
2555             memcpy(st->codec->subtitle_header, st->internal->avctx->subtitle_header,
2556                    st->codec->subtitle_header_size);
2557         }
2558 FF_ENABLE_DEPRECATION_WARNINGS
2559 #endif
2560
2561         st->internal->avctx_inited = 0;
2562     }
2563
2564     estimate_timings(ic, old_offset);
2565
2566 find_stream_info_err:
2567     for (i = 0; i < ic->nb_streams; i++) {
2568         avcodec_close(ic->streams[i]->internal->avctx);
2569         av_freep(&ic->streams[i]->info);
2570         av_bsf_free(&ic->streams[i]->internal->extract_extradata.bsf);
2571         av_packet_free(&ic->streams[i]->internal->extract_extradata.pkt);
2572     }
2573     return ret;
2574 }
2575
2576 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2577 {
2578     int i, j;
2579
2580     for (i = 0; i < ic->nb_programs; i++)
2581         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2582             if (ic->programs[i]->stream_index[j] == s)
2583                 return ic->programs[i];
2584     return NULL;
2585 }
2586
2587 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
2588                         int wanted_stream_nb, int related_stream,
2589                         AVCodec **decoder_ret, int flags)
2590 {
2591     int i, nb_streams = ic->nb_streams;
2592     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2593     unsigned *program = NULL;
2594     AVCodec *decoder = NULL, *best_decoder = NULL;
2595
2596     if (related_stream >= 0 && wanted_stream_nb < 0) {
2597         AVProgram *p = find_program_from_stream(ic, related_stream);
2598         if (p) {
2599             program    = p->stream_index;
2600             nb_streams = p->nb_stream_indexes;
2601         }
2602     }
2603     for (i = 0; i < nb_streams; i++) {
2604         int real_stream_index = program ? program[i] : i;
2605         AVStream *st          = ic->streams[real_stream_index];
2606         AVCodecParameters *par = st->codecpar;
2607         if (par->codec_type != type)
2608             continue;
2609         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2610             continue;
2611         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
2612                                AV_DISPOSITION_VISUAL_IMPAIRED))
2613             continue;
2614         if (decoder_ret) {
2615             decoder = avcodec_find_decoder(par->codec_id);
2616             if (!decoder) {
2617                 if (ret < 0)
2618                     ret = AVERROR_DECODER_NOT_FOUND;
2619                 continue;
2620             }
2621         }
2622         if (best_count >= st->codec_info_nb_frames)
2623             continue;
2624         best_count   = st->codec_info_nb_frames;
2625         ret          = real_stream_index;
2626         best_decoder = decoder;
2627         if (program && i == nb_streams - 1 && ret < 0) {
2628             program    = NULL;
2629             nb_streams = ic->nb_streams;
2630             /* no related stream found, try again with everything */
2631             i = 0;
2632         }
2633     }
2634     if (decoder_ret)
2635         *decoder_ret = best_decoder;
2636     return ret;
2637 }
2638
2639 /*******************************************************/
2640
2641 int av_read_play(AVFormatContext *s)
2642 {
2643     if (s->iformat->read_play)
2644         return s->iformat->read_play(s);
2645     if (s->pb)
2646         return avio_pause(s->pb, 0);
2647     return AVERROR(ENOSYS);
2648 }
2649
2650 int av_read_pause(AVFormatContext *s)
2651 {
2652     if (s->iformat->read_pause)
2653         return s->iformat->read_pause(s);
2654     if (s->pb)
2655         return avio_pause(s->pb, 1);
2656     return AVERROR(ENOSYS);
2657 }
2658
2659 static void free_stream(AVStream **pst)
2660 {
2661     AVStream *st = *pst;
2662     int i;
2663
2664     if (!st)
2665         return;
2666
2667     for (i = 0; i < st->nb_side_data; i++)
2668         av_freep(&st->side_data[i].data);
2669     av_freep(&st->side_data);
2670
2671     if (st->parser)
2672         av_parser_close(st->parser);
2673
2674     if (st->attached_pic.data)
2675         av_packet_unref(&st->attached_pic);
2676
2677     if (st->internal) {
2678         avcodec_free_context(&st->internal->avctx);
2679         av_bsf_free(&st->internal->extract_extradata.bsf);
2680         av_packet_free(&st->internal->extract_extradata.pkt);
2681     }
2682     av_freep(&st->internal);
2683
2684     av_dict_free(&st->metadata);
2685     avcodec_parameters_free(&st->codecpar);
2686     av_freep(&st->probe_data.buf);
2687     av_free(st->index_entries);
2688 #if FF_API_LAVF_AVCTX
2689 FF_DISABLE_DEPRECATION_WARNINGS
2690     av_free(st->codec->extradata);
2691     av_free(st->codec->subtitle_header);
2692     av_free(st->codec);
2693 FF_ENABLE_DEPRECATION_WARNINGS
2694 #endif
2695     av_free(st->priv_data);
2696     av_free(st->info);
2697
2698     av_freep(pst);
2699 }
2700
2701 void avformat_free_context(AVFormatContext *s)
2702 {
2703     int i;
2704
2705     if (!s)
2706         return;
2707
2708     av_opt_free(s);
2709     if (s->iformat && s->iformat->priv_class && s->priv_data)
2710         av_opt_free(s->priv_data);
2711
2712     for (i = 0; i < s->nb_streams; i++)
2713         free_stream(&s->streams[i]);
2714
2715     for (i = s->nb_programs - 1; i >= 0; i--) {
2716         av_dict_free(&s->programs[i]->metadata);
2717         av_freep(&s->programs[i]->stream_index);
2718         av_freep(&s->programs[i]);
2719     }
2720     av_freep(&s->programs);
2721     av_freep(&s->priv_data);
2722     while (s->nb_chapters--) {
2723         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2724         av_free(s->chapters[s->nb_chapters]);
2725     }
2726     av_freep(&s->chapters);
2727     av_dict_free(&s->metadata);
2728     av_freep(&s->streams);
2729     av_freep(&s->internal);
2730     av_free(s);
2731 }
2732
2733 void avformat_close_input(AVFormatContext **ps)
2734 {
2735     AVFormatContext *s = *ps;
2736     AVIOContext *pb    = s->pb;
2737
2738     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2739         (s->flags & AVFMT_FLAG_CUSTOM_IO))
2740         pb = NULL;
2741
2742     flush_packet_queue(s);
2743
2744     if (s->iformat)
2745         if (s->iformat->read_close)
2746             s->iformat->read_close(s);
2747
2748     avformat_free_context(s);
2749
2750     *ps = NULL;
2751
2752     avio_close(pb);
2753 }
2754
2755 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
2756 {
2757     AVStream *st;
2758     int i;
2759
2760     if (av_reallocp_array(&s->streams, s->nb_streams + 1,
2761                           sizeof(*s->streams)) < 0) {
2762         s->nb_streams = 0;
2763         return NULL;
2764     }
2765
2766     st = av_mallocz(sizeof(AVStream));
2767     if (!st)
2768         return NULL;
2769     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2770         av_free(st);
2771         return NULL;
2772     }
2773
2774 #if FF_API_LAVF_AVCTX
2775 FF_DISABLE_DEPRECATION_WARNINGS
2776     st->codec = avcodec_alloc_context3(c);
2777     if (!st->codec) {
2778         av_free(st->info);
2779         av_free(st);
2780         return NULL;
2781     }
2782 FF_ENABLE_DEPRECATION_WARNINGS
2783 #endif
2784
2785     st->internal = av_mallocz(sizeof(*st->internal));
2786     if (!st->internal)
2787         goto fail;
2788
2789     if (s->iformat) {
2790 #if FF_API_LAVF_AVCTX
2791 FF_DISABLE_DEPRECATION_WARNINGS
2792         /* no default bitrate if decoding */
2793         st->codec->bit_rate = 0;
2794 FF_ENABLE_DEPRECATION_WARNINGS
2795 #endif
2796
2797         /* default pts setting is MPEG-like */
2798         avpriv_set_pts_info(st, 33, 1, 90000);
2799         /* we set the current DTS to 0 so that formats without any timestamps
2800          * but durations get some timestamps, formats with some unknown
2801          * timestamps have their first few packets buffered and the
2802          * timestamps corrected before they are returned to the user */
2803         st->cur_dts = 0;
2804     } else {
2805         st->cur_dts = AV_NOPTS_VALUE;
2806     }
2807
2808     st->codecpar = avcodec_parameters_alloc();
2809     if (!st->codecpar)
2810         goto fail;
2811
2812     st->internal->avctx = avcodec_alloc_context3(NULL);
2813     if (!st->internal->avctx)
2814         goto fail;
2815
2816     st->index      = s->nb_streams;
2817     st->start_time = AV_NOPTS_VALUE;
2818     st->duration   = AV_NOPTS_VALUE;
2819     st->first_dts     = AV_NOPTS_VALUE;
2820     st->probe_packets = MAX_PROBE_PACKETS;
2821
2822     st->last_IP_pts = AV_NOPTS_VALUE;
2823     for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
2824         st->pts_buffer[i] = AV_NOPTS_VALUE;
2825
2826     st->sample_aspect_ratio = (AVRational) { 0, 1 };
2827
2828     st->info->fps_first_dts = AV_NOPTS_VALUE;
2829     st->info->fps_last_dts  = AV_NOPTS_VALUE;
2830
2831 #if FF_API_LAVF_AVCTX
2832     st->internal->need_codec_update = 1;
2833 #endif
2834
2835     s->streams[s->nb_streams++] = st;
2836     return st;
2837 fail:
2838     free_stream(&st);
2839     return NULL;
2840 }
2841
2842 AVProgram *av_new_program(AVFormatContext *ac, int id)
2843 {
2844     AVProgram *program = NULL;
2845     int i;
2846
2847     av_log(ac, AV_LOG_TRACE, "new_program: id=0x%04x\n", id);
2848
2849     for (i = 0; i < ac->nb_programs; i++)
2850         if (ac->programs[i]->id == id)
2851             program = ac->programs[i];
2852
2853     if (!program) {
2854         program = av_mallocz(sizeof(AVProgram));
2855         if (!program)
2856             return NULL;
2857         dynarray_add(&ac->programs, &ac->nb_programs, program);
2858         program->discard = AVDISCARD_NONE;
2859     }
2860     program->id = id;
2861
2862     return program;
2863 }
2864
2865 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
2866                               int64_t start, int64_t end, const char *title)
2867 {
2868     AVChapter *chapter = NULL;
2869     int i;
2870
2871     for (i = 0; i < s->nb_chapters; i++)
2872         if (s->chapters[i]->id == id)
2873             chapter = s->chapters[i];
2874
2875     if (!chapter) {
2876         chapter = av_mallocz(sizeof(AVChapter));
2877         if (!chapter)
2878             return NULL;
2879         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2880     }
2881     av_dict_set(&chapter->metadata, "title", title, 0);
2882     chapter->id        = id;
2883     chapter->time_base = time_base;
2884     chapter->start     = start;
2885     chapter->end       = end;
2886
2887     return chapter;
2888 }
2889
2890 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
2891 {
2892     int i, j;
2893     AVProgram *program = NULL;
2894
2895     if (idx >= ac->nb_streams) {
2896         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2897         return;
2898     }
2899
2900     for (i = 0; i < ac->nb_programs; i++) {
2901         if (ac->programs[i]->id != progid)
2902             continue;
2903         program = ac->programs[i];
2904         for (j = 0; j < program->nb_stream_indexes; j++)
2905             if (program->stream_index[j] == idx)
2906                 return;
2907
2908         if (av_reallocp_array(&program->stream_index,
2909                               program->nb_stream_indexes + 1,
2910                               sizeof(*program->stream_index)) < 0) {
2911             program->nb_stream_indexes = 0;
2912             return;
2913         }
2914         program->stream_index[program->nb_stream_indexes++] = idx;
2915         return;
2916     }
2917 }
2918
2919 uint64_t ff_ntp_time(void)
2920 {
2921     return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
2922 }
2923
2924 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
2925 {
2926     const char *p;
2927     char *q, buf1[20], c;
2928     int nd, len, percentd_found;
2929
2930     q = buf;
2931     p = path;
2932     percentd_found = 0;
2933     for (;;) {
2934         c = *p++;
2935         if (c == '\0')
2936             break;
2937         if (c == '%') {
2938             do {
2939                 nd = 0;
2940                 while (av_isdigit(*p))
2941                     nd = nd * 10 + *p++ - '0';
2942                 c = *p++;
2943             } while (av_isdigit(c));
2944
2945             switch (c) {
2946             case '%':
2947                 goto addchar;
2948             case 'd':
2949                 if (percentd_found)
2950                     goto fail;
2951                 percentd_found = 1;
2952                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2953                 len = strlen(buf1);
2954                 if ((q - buf + len) > buf_size - 1)
2955                     goto fail;
2956                 memcpy(q, buf1, len);
2957                 q += len;
2958                 break;
2959             default:
2960                 goto fail;
2961             }
2962         } else {
2963 addchar:
2964             if ((q - buf) < buf_size - 1)
2965                 *q++ = c;
2966         }
2967     }
2968     if (!percentd_found)
2969         goto fail;
2970     *q = '\0';
2971     return 0;
2972 fail:
2973     *q = '\0';
2974     return -1;
2975 }
2976
2977 void av_url_split(char *proto, int proto_size,
2978                   char *authorization, int authorization_size,
2979                   char *hostname, int hostname_size,
2980                   int *port_ptr, char *path, int path_size, const char *url)
2981 {
2982     const char *p, *ls, *at, *col, *brk;
2983
2984     if (port_ptr)
2985         *port_ptr = -1;
2986     if (proto_size > 0)
2987         proto[0] = 0;
2988     if (authorization_size > 0)
2989         authorization[0] = 0;
2990     if (hostname_size > 0)
2991         hostname[0] = 0;
2992     if (path_size > 0)
2993         path[0] = 0;
2994
2995     /* parse protocol */
2996     if ((p = strchr(url, ':'))) {
2997         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2998         p++; /* skip ':' */
2999         if (*p == '/')
3000             p++;
3001         if (*p == '/')
3002             p++;
3003     } else {
3004         /* no protocol means plain filename */
3005         av_strlcpy(path, url, path_size);
3006         return;
3007     }
3008
3009     /* separate path from hostname */
3010     ls = strchr(p, '/');
3011     if (!ls)
3012         ls = strchr(p, '?');
3013     if (ls)
3014         av_strlcpy(path, ls, path_size);
3015     else
3016         ls = &p[strlen(p)];  // XXX
3017
3018     /* the rest is hostname, use that to parse auth/port */
3019     if (ls != p) {
3020         /* authorization (user[:pass]@hostname) */
3021         if ((at = strchr(p, '@')) && at < ls) {
3022             av_strlcpy(authorization, p,
3023                        FFMIN(authorization_size, at + 1 - p));
3024             p = at + 1; /* skip '@' */
3025         }
3026
3027         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3028             /* [host]:port */
3029             av_strlcpy(hostname, p + 1,
3030                        FFMIN(hostname_size, brk - p));
3031             if (brk[1] == ':' && port_ptr)
3032                 *port_ptr = atoi(brk + 2);
3033         } else if ((col = strchr(p, ':')) && col < ls) {
3034             av_strlcpy(hostname, p,
3035                        FFMIN(col + 1 - p, hostname_size));
3036             if (port_ptr)
3037                 *port_ptr = atoi(col + 1);
3038         } else
3039             av_strlcpy(hostname, p,
3040                        FFMIN(ls + 1 - p, hostname_size));
3041     }
3042 }
3043
3044 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3045 {
3046     int i;
3047     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3048                                            '4', '5', '6', '7',
3049                                            '8', '9', 'A', 'B',
3050                                            'C', 'D', 'E', 'F' };
3051     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3052                                            '4', '5', '6', '7',
3053                                            '8', '9', 'a', 'b',
3054                                            'c', 'd', 'e', 'f' };
3055     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3056
3057     for (i = 0; i < s; i++) {
3058         buff[i * 2]     = hex_table[src[i] >> 4];
3059         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3060     }
3061
3062     return buff;
3063 }
3064
3065 int ff_hex_to_data(uint8_t *data, const char *p)
3066 {
3067     int c, len, v;
3068
3069     len = 0;
3070     v   = 1;
3071     for (;;) {
3072         p += strspn(p, SPACE_CHARS);
3073         if (*p == '\0')
3074             break;
3075         c = av_toupper((unsigned char) *p++);
3076         if (c >= '0' && c <= '9')
3077             c = c - '0';
3078         else if (c >= 'A' && c <= 'F')
3079             c = c - 'A' + 10;
3080         else
3081             break;
3082         v = (v << 4) | c;
3083         if (v & 0x100) {
3084             if (data)
3085                 data[len] = v;
3086             len++;
3087             v = 1;
3088         }
3089     }
3090     return len;
3091 }
3092
3093 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3094                          unsigned int pts_num, unsigned int pts_den)
3095 {
3096     AVRational new_tb;
3097     if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3098         if (new_tb.num != pts_num)
3099             av_log(NULL, AV_LOG_DEBUG,
3100                    "st:%d removing common factor %d from timebase\n",
3101                    s->index, pts_num / new_tb.num);
3102     } else
3103         av_log(NULL, AV_LOG_WARNING,
3104                "st:%d has too large timebase, reducing\n", s->index);
3105
3106     if (new_tb.num <= 0 || new_tb.den <= 0) {
3107         av_log(NULL, AV_LOG_ERROR,
3108                "Ignoring attempt to set invalid timebase for st:%d\n",
3109                s->index);
3110         return;
3111     }
3112     s->time_base     = new_tb;
3113     s->pts_wrap_bits = pts_wrap_bits;
3114 }
3115
3116 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3117                         void *context)
3118 {
3119     const char *ptr = str;
3120
3121     /* Parse key=value pairs. */
3122     for (;;) {
3123         const char *key;
3124         char *dest = NULL, *dest_end;
3125         int key_len, dest_len = 0;
3126
3127         /* Skip whitespace and potential commas. */
3128         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3129             ptr++;
3130         if (!*ptr)
3131             break;
3132
3133         key = ptr;
3134
3135         if (!(ptr = strchr(key, '=')))
3136             break;
3137         ptr++;
3138         key_len = ptr - key;
3139
3140         callback_get_buf(context, key, key_len, &dest, &dest_len);
3141         dest_end = dest + dest_len - 1;
3142
3143         if (*ptr == '\"') {
3144             ptr++;
3145             while (*ptr && *ptr != '\"') {
3146                 if (*ptr == '\\') {
3147                     if (!ptr[1])
3148                         break;
3149                     if (dest && dest < dest_end)
3150                         *dest++ = ptr[1];
3151                     ptr += 2;
3152                 } else {
3153                     if (dest && dest < dest_end)
3154                         *dest++ = *ptr;
3155                     ptr++;
3156                 }
3157             }
3158             if (*ptr == '\"')
3159                 ptr++;
3160         } else {
3161             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3162                 if (dest && dest < dest_end)
3163                     *dest++ = *ptr;
3164         }
3165         if (dest)
3166             *dest = 0;
3167     }
3168 }
3169
3170 int ff_find_stream_index(AVFormatContext *s, int id)
3171 {
3172     int i;
3173     for (i = 0; i < s->nb_streams; i++)
3174         if (s->streams[i]->id == id)
3175             return i;
3176     return -1;
3177 }
3178
3179 int64_t ff_iso8601_to_unix_time(const char *datestr)
3180 {
3181     struct tm time1 = { 0 }, time2 = { 0 };
3182     const char *ret1, *ret2;
3183     ret1 = av_small_strptime(datestr, "%Y - %m - %d %T", &time1);
3184     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%T", &time2);
3185     if (ret2 && !ret1)
3186         return av_timegm(&time2);
3187     else
3188         return av_timegm(&time1);
3189 }
3190
3191 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
3192                          int std_compliance)
3193 {
3194     if (ofmt) {
3195         if (ofmt->query_codec)
3196             return ofmt->query_codec(codec_id, std_compliance);
3197         else if (ofmt->codec_tag)
3198             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3199         else if (codec_id == ofmt->video_codec ||
3200                  codec_id == ofmt->audio_codec ||
3201                  codec_id == ofmt->subtitle_codec)
3202             return 1;
3203     }
3204     return AVERROR_PATCHWELCOME;
3205 }
3206
3207 int avformat_network_init(void)
3208 {
3209 #if CONFIG_NETWORK
3210     int ret;
3211     ff_network_inited_globally = 1;
3212     if ((ret = ff_network_init()) < 0)
3213         return ret;
3214     ff_tls_init();
3215 #endif
3216     return 0;
3217 }
3218
3219 int avformat_network_deinit(void)
3220 {
3221 #if CONFIG_NETWORK
3222     ff_network_close();
3223     ff_tls_deinit();
3224 #endif
3225     return 0;
3226 }
3227
3228 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3229                         uint64_t channel_layout, int32_t sample_rate,
3230                         int32_t width, int32_t height)
3231 {
3232     uint32_t flags = 0;
3233     int size = 4;
3234     uint8_t *data;
3235     if (!pkt)
3236         return AVERROR(EINVAL);
3237     if (channels) {
3238         size  += 4;
3239         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3240     }
3241     if (channel_layout) {
3242         size  += 8;
3243         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3244     }
3245     if (sample_rate) {
3246         size  += 4;
3247         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3248     }
3249     if (width || height) {
3250         size  += 8;
3251         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3252     }
3253     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3254     if (!data)
3255         return AVERROR(ENOMEM);
3256     bytestream_put_le32(&data, flags);
3257     if (channels)
3258         bytestream_put_le32(&data, channels);
3259     if (channel_layout)
3260         bytestream_put_le64(&data, channel_layout);
3261     if (sample_rate)
3262         bytestream_put_le32(&data, sample_rate);
3263     if (width || height) {
3264         bytestream_put_le32(&data, width);
3265         bytestream_put_le32(&data, height);
3266     }
3267     return 0;
3268 }
3269
3270 int ff_generate_avci_extradata(AVStream *st)
3271 {
3272     static const uint8_t avci100_1080p_extradata[] = {
3273         // SPS
3274         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3275         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3276         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3277         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
3278         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
3279         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
3280         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
3281         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
3282         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3283         // PPS
3284         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3285         0xd0
3286     };
3287     static const uint8_t avci100_1080i_extradata[] = {
3288         // SPS
3289         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3290         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3291         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3292         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
3293         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
3294         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
3295         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
3296         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
3297         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
3298         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
3299         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
3300         // PPS
3301         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3302         0xd0
3303     };
3304     static const uint8_t avci50_1080i_extradata[] = {
3305         // SPS
3306         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
3307         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
3308         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
3309         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
3310         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
3311         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
3312         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
3313         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
3314         0x81, 0x13, 0xf7, 0xff, 0x80, 0x01, 0x80, 0x02,
3315         0x71, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
3316         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
3317         // PPS
3318         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
3319         0x11
3320     };
3321     static const uint8_t avci100_720p_extradata[] = {
3322         // SPS
3323         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3324         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
3325         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
3326         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
3327         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
3328         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
3329         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
3330         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
3331         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
3332         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
3333         // PPS
3334         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
3335         0x11
3336     };
3337
3338     const uint8_t *data = NULL;
3339     int size            = 0;
3340
3341     if (st->codecpar->width == 1920) {
3342         if (st->codecpar->field_order == AV_FIELD_PROGRESSIVE) {
3343             data = avci100_1080p_extradata;
3344             size = sizeof(avci100_1080p_extradata);
3345         } else {
3346             data = avci100_1080i_extradata;
3347             size = sizeof(avci100_1080i_extradata);
3348         }
3349     } else if (st->codecpar->width == 1440) {
3350         data = avci50_1080i_extradata;
3351         size = sizeof(avci50_1080i_extradata);
3352     } else if (st->codecpar->width == 1280) {
3353         data = avci100_720p_extradata;
3354         size = sizeof(avci100_720p_extradata);
3355     }
3356
3357     if (!size)
3358         return 0;
3359
3360     av_freep(&st->codecpar->extradata);
3361     st->codecpar->extradata_size = 0;
3362     st->codecpar->extradata      = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
3363     if (!st->codecpar->extradata)
3364         return AVERROR(ENOMEM);
3365
3366     memcpy(st->codecpar->extradata, data, size);
3367     st->codecpar->extradata_size = size;
3368
3369     return 0;
3370 }
3371
3372 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
3373                                  int *size)
3374 {
3375     int i;
3376
3377     for (i = 0; i < st->nb_side_data; i++) {
3378         if (st->side_data[i].type == type) {
3379             if (size)
3380                 *size = st->side_data[i].size;
3381             return st->side_data[i].data;
3382         }
3383     }
3384     return NULL;
3385 }
3386
3387 int av_stream_add_side_data(AVStream *st, enum AVPacketSideDataType type,
3388                             uint8_t *data, size_t size)
3389 {
3390     AVPacketSideData *sd, *tmp;
3391     int i;
3392
3393     for (i = 0; i < st->nb_side_data; i++) {
3394         sd = &st->side_data[i];
3395
3396         if (sd->type == type) {
3397             av_freep(&sd->data);
3398             sd->data = data;
3399             sd->size = size;
3400             return 0;
3401         }
3402     }
3403
3404     if ((unsigned) st->nb_side_data + 1 >= INT_MAX / sizeof(*st->side_data))
3405         return AVERROR(ERANGE);
3406
3407     tmp = av_realloc(st->side_data, (st->nb_side_data + 1) * sizeof(*tmp));
3408     if (!tmp) {
3409         return AVERROR(ENOMEM);
3410     }
3411
3412     st->side_data = tmp;
3413     st->nb_side_data++;
3414
3415     sd = &st->side_data[st->nb_side_data - 1];
3416     sd->type = type;
3417     sd->data = data;
3418     sd->size = size;
3419
3420     return 0;
3421 }
3422
3423 uint8_t *av_stream_new_side_data(AVStream *st, enum AVPacketSideDataType type,
3424                                  int size)
3425 {
3426     int ret;
3427     uint8_t *data = av_malloc(size);
3428
3429     if (!data)
3430         return NULL;
3431
3432     ret = av_stream_add_side_data(st, type, data, size);
3433     if (ret < 0) {
3434         av_freep(&data);
3435         return NULL;
3436     }
3437
3438     return data;
3439 }
3440
3441 void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
3442 {
3443     if (*pb)
3444         s->io_close(s, *pb);
3445     *pb = NULL;
3446 }