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