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