Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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