| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * Core demuxing component | ||
| 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 <stdint.h> | ||
| 23 | |||
| 24 | #include "config_components.h" | ||
| 25 | |||
| 26 | #include "libavutil/avassert.h" | ||
| 27 | #include "libavutil/avstring.h" | ||
| 28 | #include "libavutil/dict.h" | ||
| 29 | #include "libavutil/internal.h" | ||
| 30 | #include "libavutil/intreadwrite.h" | ||
| 31 | #include "libavutil/mathematics.h" | ||
| 32 | #include "libavutil/mem.h" | ||
| 33 | #include "libavutil/opt.h" | ||
| 34 | #include "libavutil/pixfmt.h" | ||
| 35 | #include "libavutil/time.h" | ||
| 36 | #include "libavutil/timestamp.h" | ||
| 37 | |||
| 38 | #include "libavcodec/avcodec.h" | ||
| 39 | #include "libavcodec/bsf.h" | ||
| 40 | #include "libavcodec/codec_desc.h" | ||
| 41 | #include "libavcodec/internal.h" | ||
| 42 | #include "packet_internal.h" | ||
| 43 | #include "libavcodec/raw.h" | ||
| 44 | |||
| 45 | #include "avformat.h" | ||
| 46 | #include "avformat_internal.h" | ||
| 47 | #include "avio_internal.h" | ||
| 48 | #include "demux.h" | ||
| 49 | #include "id3v2.h" | ||
| 50 | #include "internal.h" | ||
| 51 | #include "url.h" | ||
| 52 | |||
| 53 | 2615169 | static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp) | |
| 54 | { | ||
| 55 | 2615169 | const FFStream *const sti = cffstream(st); | |
| 56 |
4/4✓ Branch 0 taken 164018 times.
✓ Branch 1 taken 2451151 times.
✓ Branch 2 taken 159000 times.
✓ Branch 3 taken 5018 times.
|
2615169 | if (sti->pts_wrap_behavior != AV_PTS_WRAP_IGNORE && st->pts_wrap_bits < 64 && |
| 57 |
4/4✓ Branch 0 taken 157694 times.
✓ Branch 1 taken 1306 times.
✓ Branch 2 taken 96516 times.
✓ Branch 3 taken 61178 times.
|
159000 | sti->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) { |
| 58 |
2/2✓ Branch 0 taken 96312 times.
✓ Branch 1 taken 204 times.
|
96516 | if (sti->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET && |
| 59 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 96312 times.
|
96312 | timestamp < sti->pts_wrap_reference) |
| 60 | ✗ | return timestamp + (1ULL << st->pts_wrap_bits); | |
| 61 |
2/2✓ Branch 0 taken 204 times.
✓ Branch 1 taken 96312 times.
|
96516 | else if (sti->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET && |
| 62 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 154 times.
|
204 | timestamp >= sti->pts_wrap_reference) |
| 63 | 50 | return timestamp - (1ULL << st->pts_wrap_bits); | |
| 64 | } | ||
| 65 | 2615119 | return timestamp; | |
| 66 | } | ||
| 67 | |||
| 68 | 354759 | int64_t ff_wrap_timestamp(const AVStream *st, int64_t timestamp) | |
| 69 | { | ||
| 70 | 354759 | return wrap_timestamp(st, timestamp); | |
| 71 | } | ||
| 72 | |||
| 73 | 10439 | static const AVCodec *find_probe_decoder(AVFormatContext *s, const AVStream *st, enum AVCodecID codec_id) | |
| 74 | { | ||
| 75 | const AVCodec *codec; | ||
| 76 | |||
| 77 | #if CONFIG_H264_DECODER | ||
| 78 | /* Other parts of the code assume this decoder to be used for h264, | ||
| 79 | * so force it if possible. */ | ||
| 80 |
2/2✓ Branch 0 taken 350 times.
✓ Branch 1 taken 10089 times.
|
10439 | if (codec_id == AV_CODEC_ID_H264) |
| 81 | 350 | return avcodec_find_decoder_by_name("h264"); | |
| 82 | #endif | ||
| 83 | |||
| 84 | 10089 | codec = ff_find_decoder(s, st, codec_id); | |
| 85 |
2/2✓ Branch 0 taken 212 times.
✓ Branch 1 taken 9877 times.
|
10089 | if (!codec) |
| 86 | 212 | return NULL; | |
| 87 | |||
| 88 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9877 times.
|
9877 | if (codec->capabilities & AV_CODEC_CAP_AVOID_PROBING) { |
| 89 | ✗ | const AVCodec *probe_codec = NULL; | |
| 90 | ✗ | void *iter = NULL; | |
| 91 | ✗ | while ((probe_codec = av_codec_iterate(&iter))) { | |
| 92 | ✗ | if (probe_codec->id == codec->id && | |
| 93 | ✗ | av_codec_is_decoder(probe_codec) && | |
| 94 | ✗ | !(probe_codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | AV_CODEC_CAP_EXPERIMENTAL))) { | |
| 95 | ✗ | return probe_codec; | |
| 96 | } | ||
| 97 | } | ||
| 98 | } | ||
| 99 | |||
| 100 | 9877 | return codec; | |
| 101 | } | ||
| 102 | |||
| 103 | 3370 | static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, | |
| 104 | AVProbeData *pd) | ||
| 105 | { | ||
| 106 | static const struct { | ||
| 107 | const char *name; | ||
| 108 | enum AVCodecID id; | ||
| 109 | enum AVMediaType type; | ||
| 110 | } fmt_id_type[] = { | ||
| 111 | { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO }, | ||
| 112 | { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO }, | ||
| 113 | { "aptx", AV_CODEC_ID_APTX, AVMEDIA_TYPE_AUDIO }, | ||
| 114 | { "av1", AV_CODEC_ID_AV1, AVMEDIA_TYPE_VIDEO }, | ||
| 115 | { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO }, | ||
| 116 | { "dvbsub", AV_CODEC_ID_DVB_SUBTITLE, AVMEDIA_TYPE_SUBTITLE }, | ||
| 117 | { "dvbtxt", AV_CODEC_ID_DVB_TELETEXT, AVMEDIA_TYPE_SUBTITLE }, | ||
| 118 | { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO }, | ||
| 119 | { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO }, | ||
| 120 | { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO }, | ||
| 121 | { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO }, | ||
| 122 | { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO }, | ||
| 123 | { "mjpeg_2000", AV_CODEC_ID_JPEG2000, AVMEDIA_TYPE_VIDEO }, | ||
| 124 | { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO }, | ||
| 125 | { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO }, | ||
| 126 | { "truehd", AV_CODEC_ID_TRUEHD, AVMEDIA_TYPE_AUDIO }, | ||
| 127 | { "evc", AV_CODEC_ID_EVC, AVMEDIA_TYPE_VIDEO }, | ||
| 128 | { "vvc", AV_CODEC_ID_VVC, AVMEDIA_TYPE_VIDEO }, | ||
| 129 | { 0 } | ||
| 130 | }; | ||
| 131 | int score; | ||
| 132 | 3370 | const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score); | |
| 133 | 3370 | FFStream *const sti = ffstream(st); | |
| 134 | |||
| 135 |
2/2✓ Branch 0 taken 1182 times.
✓ Branch 1 taken 2188 times.
|
3370 | if (fmt) { |
| 136 | 1182 | av_log(s, AV_LOG_DEBUG, | |
| 137 | "Probe with size=%d, packets=%d detected %s with score=%d\n", | ||
| 138 | 1182 | pd->buf_size, s->max_probe_packets - sti->probe_packets, | |
| 139 | 1182 | fmt->name, score); | |
| 140 |
2/2✓ Branch 0 taken 21114 times.
✓ Branch 1 taken 1159 times.
|
22273 | for (int i = 0; fmt_id_type[i].name; i++) { |
| 141 |
2/2✓ Branch 0 taken 29 times.
✓ Branch 1 taken 21085 times.
|
21114 | if (!strcmp(fmt->name, fmt_id_type[i].name)) { |
| 142 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 18 times.
|
29 | if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO && |
| 143 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
|
11 | st->codecpar->sample_rate) |
| 144 | ✗ | continue; | |
| 145 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 19 times.
|
29 | if (sti->request_probe > score && |
| 146 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
|
10 | st->codecpar->codec_id != fmt_id_type[i].id) |
| 147 | 6 | continue; | |
| 148 | 23 | st->codecpar->codec_id = fmt_id_type[i].id; | |
| 149 | 23 | st->codecpar->codec_type = fmt_id_type[i].type; | |
| 150 | 23 | sti->need_context_update = 1; | |
| 151 | 23 | return score; | |
| 152 | } | ||
| 153 | } | ||
| 154 | } | ||
| 155 | 3347 | return 0; | |
| 156 | } | ||
| 157 | |||
| 158 | 8162 | static int init_input(AVFormatContext *s, const char *filename, | |
| 159 | AVDictionary **options) | ||
| 160 | { | ||
| 161 | int ret; | ||
| 162 | 8162 | AVProbeData pd = { filename, NULL, 0 }; | |
| 163 | 8162 | int score = AVPROBE_SCORE_RETRY; | |
| 164 | |||
| 165 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 8145 times.
|
8162 | if (s->pb) { |
| 166 | 17 | s->flags |= AVFMT_FLAG_CUSTOM_IO; | |
| 167 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
|
17 | if (!s->iformat) |
| 168 | ✗ | return av_probe_input_buffer2(s->pb, &s->iformat, filename, | |
| 169 | ✗ | s, 0, s->format_probesize); | |
| 170 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
|
17 | else if (s->iformat->flags & AVFMT_NOFILE) |
| 171 | ✗ | av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and " | |
| 172 | "will be ignored with AVFMT_NOFILE format.\n"); | ||
| 173 | 17 | return 0; | |
| 174 | } | ||
| 175 | |||
| 176 |
4/4✓ Branch 0 taken 3955 times.
✓ Branch 1 taken 4190 times.
✓ Branch 2 taken 957 times.
✓ Branch 3 taken 2998 times.
|
8145 | if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) || |
| 177 |
4/4✓ Branch 0 taken 4190 times.
✓ Branch 1 taken 957 times.
✓ Branch 3 taken 199 times.
✓ Branch 4 taken 3991 times.
|
5147 | (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score)))) |
| 178 | 3197 | return score; | |
| 179 | |||
| 180 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4948 times.
|
4948 | if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0) |
| 181 | ✗ | return ret; | |
| 182 | |||
| 183 |
2/2✓ Branch 0 taken 957 times.
✓ Branch 1 taken 3991 times.
|
4948 | if (s->iformat) |
| 184 | 957 | return 0; | |
| 185 | 3991 | return av_probe_input_buffer2(s->pb, &s->iformat, filename, | |
| 186 | 3991 | s, 0, s->format_probesize); | |
| 187 | } | ||
| 188 | |||
| 189 | static int codec_close(FFStream *sti); | ||
| 190 | |||
| 191 | 217132 | static int update_stream_avctx(AVFormatContext *s) | |
| 192 | { | ||
| 193 | int ret; | ||
| 194 |
2/2✓ Branch 0 taken 261383 times.
✓ Branch 1 taken 217132 times.
|
478515 | for (unsigned i = 0; i < s->nb_streams; i++) { |
| 195 | 261383 | AVStream *const st = s->streams[i]; | |
| 196 | 261383 | FFStream *const sti = ffstream(st); | |
| 197 | |||
| 198 |
2/2✓ Branch 0 taken 252460 times.
✓ Branch 1 taken 8923 times.
|
261383 | if (!sti->need_context_update) |
| 199 | 252460 | continue; | |
| 200 | |||
| 201 |
2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 8921 times.
|
8923 | if (avcodec_is_open(sti->avctx)) { |
| 202 | 2 | av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n"); | |
| 203 | 2 | ret = codec_close(sti); | |
| 204 | 2 | sti->info->found_decoder = 0; | |
| 205 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret < 0) |
| 206 | ✗ | return ret; | |
| 207 | } | ||
| 208 | |||
| 209 | /* close parser, because it depends on the codec */ | ||
| 210 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8921 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
8923 | if (sti->parser && sti->avctx->codec_id != st->codecpar->codec_id) { |
| 211 | ✗ | av_parser_close(sti->parser); | |
| 212 | ✗ | sti->parser = NULL; | |
| 213 | } | ||
| 214 | |||
| 215 | /* update internal codec context, for the parser */ | ||
| 216 | 8923 | ret = avcodec_parameters_to_context(sti->avctx, st->codecpar); | |
| 217 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8923 times.
|
8923 | if (ret < 0) |
| 218 | ✗ | return ret; | |
| 219 | |||
| 220 | 8923 | sti->codec_desc = avcodec_descriptor_get(sti->avctx->codec_id); | |
| 221 | |||
| 222 | 8923 | sti->need_context_update = 0; | |
| 223 | } | ||
| 224 | 217132 | return 0; | |
| 225 | } | ||
| 226 | |||
| 227 | 4965 | static av_always_inline int is_id3v2_format(const AVInputFormat *fmt) { | |
| 228 | 4965 | return ffifmt(fmt)->flags_internal & FF_INFMT_FLAG_ID3V2_AUTO; | |
| 229 | } | ||
| 230 | |||
| 231 | 8162 | int avformat_open_input(AVFormatContext **ps, const char *filename, | |
| 232 | const AVInputFormat *fmt, AVDictionary **options) | ||
| 233 | { | ||
| 234 | FormatContextInternal *fci; | ||
| 235 | 8162 | AVFormatContext *s = *ps; | |
| 236 | FFFormatContext *si; | ||
| 237 | 8162 | AVDictionary *tmp = NULL; | |
| 238 | 8162 | ID3v2ExtraMeta *id3v2_extra_meta = NULL; | |
| 239 | 8162 | int ret = 0; | |
| 240 | |||
| 241 |
3/4✓ Branch 0 taken 29 times.
✓ Branch 1 taken 8133 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 29 times.
|
8162 | if (!s && !(s = avformat_alloc_context())) |
| 242 | ✗ | return AVERROR(ENOMEM); | |
| 243 | 8162 | fci = ff_fc_internal(s); | |
| 244 | 8162 | si = &fci->fc; | |
| 245 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8162 times.
|
8162 | if (!s->av_class) { |
| 246 | ✗ | av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n"); | |
| 247 | ✗ | return AVERROR(EINVAL); | |
| 248 | } | ||
| 249 |
2/2✓ Branch 0 taken 3972 times.
✓ Branch 1 taken 4190 times.
|
8162 | if (fmt) |
| 250 | 3972 | s->iformat = fmt; | |
| 251 | |||
| 252 |
2/2✓ Branch 0 taken 8146 times.
✓ Branch 1 taken 16 times.
|
8162 | if (options) |
| 253 | 8146 | av_dict_copy(&tmp, *options, 0); | |
| 254 | |||
| 255 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 8145 times.
|
8162 | if (s->pb) // must be before any goto fail |
| 256 | 17 | s->flags |= AVFMT_FLAG_CUSTOM_IO; | |
| 257 | |||
| 258 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8162 times.
|
8162 | if ((ret = av_opt_set_dict(s, &tmp)) < 0) |
| 259 | ✗ | goto fail; | |
| 260 | |||
| 261 |
2/4✓ Branch 0 taken 8162 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 8162 times.
|
8162 | if (!(s->url = av_strdup(filename ? filename : ""))) { |
| 262 | ✗ | ret = AVERROR(ENOMEM); | |
| 263 | ✗ | goto fail; | |
| 264 | } | ||
| 265 | |||
| 266 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8162 times.
|
8162 | if ((ret = init_input(s, filename, &tmp)) < 0) |
| 267 | ✗ | goto fail; | |
| 268 | 8162 | s->probe_score = ret; | |
| 269 | |||
| 270 |
6/6✓ Branch 0 taken 8074 times.
✓ Branch 1 taken 88 times.
✓ Branch 2 taken 4877 times.
✓ Branch 3 taken 3197 times.
✓ Branch 4 taken 4876 times.
✓ Branch 5 taken 1 times.
|
8162 | if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) { |
| 271 | 4876 | s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist); | |
| 272 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4876 times.
|
4876 | if (!s->protocol_whitelist) { |
| 273 | ✗ | ret = AVERROR(ENOMEM); | |
| 274 | ✗ | goto fail; | |
| 275 | } | ||
| 276 | } | ||
| 277 | |||
| 278 |
4/6✓ Branch 0 taken 8162 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4965 times.
✓ Branch 3 taken 3197 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 4965 times.
|
8162 | if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) { |
| 279 | ✗ | s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist); | |
| 280 | ✗ | if (!s->protocol_blacklist) { | |
| 281 | ✗ | ret = AVERROR(ENOMEM); | |
| 282 | ✗ | goto fail; | |
| 283 | } | ||
| 284 | } | ||
| 285 | |||
| 286 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 8162 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
8162 | if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) { |
| 287 | ✗ | av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist); | |
| 288 | ✗ | ret = AVERROR(EINVAL); | |
| 289 | ✗ | goto fail; | |
| 290 | } | ||
| 291 | |||
| 292 | 8162 | avio_skip(s->pb, s->skip_initial_bytes); | |
| 293 | |||
| 294 | /* Check filename in case an image number is expected. */ | ||
| 295 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8162 times.
|
8162 | if (s->iformat->flags & AVFMT_NEEDNUMBER) { |
| 296 | ✗ | if (!av_filename_number_test(filename)) { | |
| 297 | ✗ | ret = AVERROR(EINVAL); | |
| 298 | ✗ | goto fail; | |
| 299 | } | ||
| 300 | } | ||
| 301 | |||
| 302 | 8162 | s->duration = s->start_time = AV_NOPTS_VALUE; | |
| 303 | |||
| 304 | /* Allocate private data. */ | ||
| 305 |
2/2✓ Branch 1 taken 7997 times.
✓ Branch 2 taken 165 times.
|
8162 | if (ffifmt(s->iformat)->priv_data_size > 0) { |
| 306 |
1/2✗ Branch 2 not taken.
✓ Branch 3 taken 7997 times.
|
7997 | if (!(s->priv_data = av_mallocz(ffifmt(s->iformat)->priv_data_size))) { |
| 307 | ✗ | ret = AVERROR(ENOMEM); | |
| 308 | ✗ | goto fail; | |
| 309 | } | ||
| 310 |
2/2✓ Branch 0 taken 7043 times.
✓ Branch 1 taken 954 times.
|
7997 | if (s->iformat->priv_class) { |
| 311 | 7043 | *(const AVClass **) s->priv_data = s->iformat->priv_class; | |
| 312 | 7043 | av_opt_set_defaults(s->priv_data); | |
| 313 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 7043 times.
|
7043 | if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0) |
| 314 | ✗ | goto fail; | |
| 315 | } | ||
| 316 | } | ||
| 317 | |||
| 318 | /* e.g. AVFMT_NOFILE formats will not have an AVIOContext */ | ||
| 319 |
4/4✓ Branch 0 taken 4965 times.
✓ Branch 1 taken 3197 times.
✓ Branch 3 taken 774 times.
✓ Branch 4 taken 4191 times.
|
8162 | if (s->pb && is_id3v2_format(s->iformat)) |
| 320 | 774 | ff_id3v2_read_dict(s, s->pb, &si->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta); | |
| 321 | |||
| 322 |
1/2✓ Branch 1 taken 8162 times.
✗ Branch 2 not taken.
|
8162 | if (ffifmt(s->iformat)->read_header) |
| 323 |
2/2✓ Branch 2 taken 1 times.
✓ Branch 3 taken 8161 times.
|
8162 | if ((ret = ffifmt(s->iformat)->read_header(s)) < 0) { |
| 324 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (ffifmt(s->iformat)->flags_internal & FF_INFMT_FLAG_INIT_CLEANUP) |
| 325 | ✗ | goto close; | |
| 326 | 1 | goto fail; | |
| 327 | } | ||
| 328 | |||
| 329 |
2/2✓ Branch 0 taken 6648 times.
✓ Branch 1 taken 1513 times.
|
8161 | if (!s->metadata) { |
| 330 | 6648 | s->metadata = si->id3v2_meta; | |
| 331 | 6648 | si->id3v2_meta = NULL; | |
| 332 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1513 times.
|
1513 | } else if (si->id3v2_meta) { |
| 333 | ✗ | av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n"); | |
| 334 | ✗ | av_dict_free(&si->id3v2_meta); | |
| 335 | } | ||
| 336 | |||
| 337 |
2/2✓ Branch 0 taken 31 times.
✓ Branch 1 taken 8130 times.
|
8161 | if (id3v2_extra_meta) { |
| 338 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0) |
| 339 | ✗ | goto close; | |
| 340 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0) |
| 341 | ✗ | goto close; | |
| 342 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0) |
| 343 | ✗ | goto close; | |
| 344 | 31 | ff_id3v2_free_extra_meta(&id3v2_extra_meta); | |
| 345 | } | ||
| 346 | |||
| 347 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 8161 times.
|
8161 | if ((ret = avformat_queue_attached_pictures(s)) < 0) |
| 348 | ✗ | goto close; | |
| 349 | |||
| 350 |
4/4✓ Branch 0 taken 4964 times.
✓ Branch 1 taken 3197 times.
✓ Branch 2 taken 4445 times.
✓ Branch 3 taken 519 times.
|
8161 | if (s->pb && !si->data_offset) |
| 351 | 4445 | si->data_offset = avio_tell(s->pb); | |
| 352 | |||
| 353 | 8161 | fci->raw_packet_buffer_size = 0; | |
| 354 | |||
| 355 | 8161 | update_stream_avctx(s); | |
| 356 | |||
| 357 |
2/2✓ Branch 0 taken 8145 times.
✓ Branch 1 taken 16 times.
|
8161 | if (options) { |
| 358 | 8145 | av_dict_free(options); | |
| 359 | 8145 | *options = tmp; | |
| 360 | } | ||
| 361 | 8161 | *ps = s; | |
| 362 | 8161 | return 0; | |
| 363 | |||
| 364 | ✗ | close: | |
| 365 | ✗ | if (ffifmt(s->iformat)->read_close) | |
| 366 | ✗ | ffifmt(s->iformat)->read_close(s); | |
| 367 | ✗ | fail: | |
| 368 | 1 | ff_id3v2_free_extra_meta(&id3v2_extra_meta); | |
| 369 | 1 | av_dict_free(&tmp); | |
| 370 |
2/4✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
|
1 | if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO)) |
| 371 | 1 | ff_format_io_close(s, &s->pb); | |
| 372 | 1 | avformat_free_context(s); | |
| 373 | 1 | *ps = NULL; | |
| 374 | 1 | return ret; | |
| 375 | } | ||
| 376 | |||
| 377 | 8163 | void avformat_close_input(AVFormatContext **ps) | |
| 378 | { | ||
| 379 | AVFormatContext *s; | ||
| 380 | AVIOContext *pb; | ||
| 381 | |||
| 382 |
3/4✓ Branch 0 taken 8163 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8161 times.
|
8163 | if (!ps || !*ps) |
| 383 | 2 | return; | |
| 384 | |||
| 385 | 8161 | s = *ps; | |
| 386 | 8161 | pb = s->pb; | |
| 387 | |||
| 388 |
5/6✓ Branch 0 taken 8161 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5012 times.
✓ Branch 3 taken 3149 times.
✓ Branch 4 taken 4937 times.
✓ Branch 5 taken 75 times.
|
8161 | if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) || |
| 389 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 8069 times.
|
8086 | (s->flags & AVFMT_FLAG_CUSTOM_IO)) |
| 390 | 92 | pb = NULL; | |
| 391 | |||
| 392 |
1/2✓ Branch 0 taken 8161 times.
✗ Branch 1 not taken.
|
8161 | if (s->iformat) |
| 393 |
2/2✓ Branch 1 taken 5285 times.
✓ Branch 2 taken 2876 times.
|
8161 | if (ffifmt(s->iformat)->read_close) |
| 394 | 5285 | ffifmt(s->iformat)->read_close(s); | |
| 395 | |||
| 396 | 8161 | ff_format_io_close(s, &pb); | |
| 397 | 8161 | avformat_free_context(s); | |
| 398 | |||
| 399 | 8161 | *ps = NULL; | |
| 400 | } | ||
| 401 | |||
| 402 | 1133574 | static void force_codec_ids(AVFormatContext *s, AVStream *st) | |
| 403 | { | ||
| 404 |
5/5✓ Branch 0 taken 753837 times.
✓ Branch 1 taken 376089 times.
✓ Branch 2 taken 3450 times.
✓ Branch 3 taken 196 times.
✓ Branch 4 taken 2 times.
|
1133574 | switch (st->codecpar->codec_type) { |
| 405 | 753837 | case AVMEDIA_TYPE_VIDEO: | |
| 406 |
2/2✓ Branch 0 taken 118511 times.
✓ Branch 1 taken 635326 times.
|
753837 | if (s->video_codec_id) |
| 407 | 118511 | st->codecpar->codec_id = s->video_codec_id; | |
| 408 | 753837 | break; | |
| 409 | 376089 | case AVMEDIA_TYPE_AUDIO: | |
| 410 |
2/2✓ Branch 0 taken 4619 times.
✓ Branch 1 taken 371470 times.
|
376089 | if (s->audio_codec_id) |
| 411 | 4619 | st->codecpar->codec_id = s->audio_codec_id; | |
| 412 | 376089 | break; | |
| 413 | 3450 | case AVMEDIA_TYPE_SUBTITLE: | |
| 414 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3450 times.
|
3450 | if (s->subtitle_codec_id) |
| 415 | ✗ | st->codecpar->codec_id = s->subtitle_codec_id; | |
| 416 | 3450 | break; | |
| 417 | 196 | case AVMEDIA_TYPE_DATA: | |
| 418 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 196 times.
|
196 | if (s->data_codec_id) |
| 419 | ✗ | st->codecpar->codec_id = s->data_codec_id; | |
| 420 | 196 | break; | |
| 421 | } | ||
| 422 | 1133574 | } | |
| 423 | |||
| 424 | 23898 | static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt) | |
| 425 | { | ||
| 426 | 23898 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 427 | 23898 | FFStream *const sti = ffstream(st); | |
| 428 | |||
| 429 |
2/2✓ Branch 0 taken 17655 times.
✓ Branch 1 taken 6243 times.
|
23898 | if (sti->request_probe > 0) { |
| 430 | 17655 | AVProbeData *const pd = &sti->probe_data; | |
| 431 | int end; | ||
| 432 | 17655 | av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, sti->probe_packets); | |
| 433 | 17655 | --sti->probe_packets; | |
| 434 | |||
| 435 |
2/2✓ Branch 0 taken 17638 times.
✓ Branch 1 taken 17 times.
|
17655 | if (pkt) { |
| 436 | 17638 | uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE); | |
| 437 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17638 times.
|
17638 | if (!new_buf) { |
| 438 | ✗ | av_log(s, AV_LOG_WARNING, | |
| 439 | "Failed to reallocate probe buffer for stream %d\n", | ||
| 440 | st->index); | ||
| 441 | ✗ | goto no_packet; | |
| 442 | } | ||
| 443 | 17638 | pd->buf = new_buf; | |
| 444 | 17638 | memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size); | |
| 445 | 17638 | pd->buf_size += pkt->size; | |
| 446 | 17638 | memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE); | |
| 447 | } else { | ||
| 448 | 17 | no_packet: | |
| 449 | 17 | sti->probe_packets = 0; | |
| 450 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
|
17 | if (!pd->buf_size) { |
| 451 | ✗ | av_log(s, AV_LOG_WARNING, | |
| 452 | "nothing to probe for stream %d\n", st->index); | ||
| 453 | } | ||
| 454 | } | ||
| 455 | |||
| 456 |
1/2✓ Branch 0 taken 17655 times.
✗ Branch 1 not taken.
|
35310 | end = fci->raw_packet_buffer_size >= s->probesize || |
| 457 |
2/2✓ Branch 0 taken 554 times.
✓ Branch 1 taken 17101 times.
|
17655 | sti->probe_packets <= 0; |
| 458 | |||
| 459 |
4/4✓ Branch 0 taken 17101 times.
✓ Branch 1 taken 554 times.
✓ Branch 2 taken 2816 times.
✓ Branch 3 taken 14285 times.
|
17655 | if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) { |
| 460 | 3370 | int score = set_codec_from_probe_data(s, st, pd); | |
| 461 |
4/4✓ Branch 0 taken 3362 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 3343 times.
✓ Branch 3 taken 19 times.
|
3370 | if ( (st->codecpar->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY) |
| 462 |
2/2✓ Branch 0 taken 554 times.
✓ Branch 1 taken 2797 times.
|
3351 | || end) { |
| 463 | 573 | pd->buf_size = 0; | |
| 464 | 573 | av_freep(&pd->buf); | |
| 465 | 573 | sti->request_probe = -1; | |
| 466 |
1/2✓ Branch 0 taken 573 times.
✗ Branch 1 not taken.
|
573 | if (st->codecpar->codec_id != AV_CODEC_ID_NONE) { |
| 467 | 573 | av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index); | |
| 468 | } else | ||
| 469 | ✗ | av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index); | |
| 470 | } | ||
| 471 | 3370 | force_codec_ids(s, st); | |
| 472 | } | ||
| 473 | } | ||
| 474 | 23898 | return 0; | |
| 475 | } | ||
| 476 | |||
| 477 | 1130204 | static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt) | |
| 478 | { | ||
| 479 | 1130204 | FFStream *const sti = ffstream(st); | |
| 480 | 1130204 | int64_t ref = pkt->dts; | |
| 481 | int pts_wrap_behavior; | ||
| 482 | int64_t pts_wrap_reference; | ||
| 483 | AVProgram *first_program; | ||
| 484 | |||
| 485 |
2/2✓ Branch 0 taken 923119 times.
✓ Branch 1 taken 207085 times.
|
1130204 | if (ref == AV_NOPTS_VALUE) |
| 486 | 923119 | ref = pkt->pts; | |
| 487 |
7/8✓ Branch 0 taken 1056696 times.
✓ Branch 1 taken 73508 times.
✓ Branch 2 taken 58845 times.
✓ Branch 3 taken 997851 times.
✓ Branch 4 taken 1000 times.
✓ Branch 5 taken 57845 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 1000 times.
|
1130204 | if (sti->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow) |
| 488 | 1129204 | return 0; | |
| 489 | 1000 | ref &= (1LL << st->pts_wrap_bits)-1; | |
| 490 | |||
| 491 | // reference time stamp should be 60 s before first time stamp | ||
| 492 | 1000 | pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num); | |
| 493 | // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset | ||
| 494 | 2001 | pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) || | |
| 495 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ? |
| 496 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 999 times.
|
1001 | AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET; |
| 497 | |||
| 498 | 1000 | first_program = av_find_program_from_stream(s, NULL, stream_index); | |
| 499 | |||
| 500 |
2/2✓ Branch 0 taken 213 times.
✓ Branch 1 taken 787 times.
|
1000 | if (!first_program) { |
| 501 | 213 | int default_stream_index = av_find_default_stream_index(s); | |
| 502 | 213 | FFStream *const default_sti = ffstream(s->streams[default_stream_index]); | |
| 503 |
2/2✓ Branch 0 taken 202 times.
✓ Branch 1 taken 11 times.
|
213 | if (default_sti->pts_wrap_reference == AV_NOPTS_VALUE) { |
| 504 |
2/2✓ Branch 0 taken 395 times.
✓ Branch 1 taken 202 times.
|
597 | for (unsigned i = 0; i < s->nb_streams; i++) { |
| 505 | 395 | FFStream *const sti = ffstream(s->streams[i]); | |
| 506 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 395 times.
|
395 | if (av_find_program_from_stream(s, NULL, i)) |
| 507 | ✗ | continue; | |
| 508 | 395 | sti->pts_wrap_reference = pts_wrap_reference; | |
| 509 | 395 | sti->pts_wrap_behavior = pts_wrap_behavior; | |
| 510 | } | ||
| 511 | } else { | ||
| 512 | 11 | sti->pts_wrap_reference = default_sti->pts_wrap_reference; | |
| 513 | 11 | sti->pts_wrap_behavior = default_sti->pts_wrap_behavior; | |
| 514 | } | ||
| 515 | } else { | ||
| 516 | 787 | AVProgram *program = first_program; | |
| 517 |
2/2✓ Branch 0 taken 787 times.
✓ Branch 1 taken 94 times.
|
881 | while (program) { |
| 518 |
2/2✓ Branch 0 taken 693 times.
✓ Branch 1 taken 94 times.
|
787 | if (program->pts_wrap_reference != AV_NOPTS_VALUE) { |
| 519 | 693 | pts_wrap_reference = program->pts_wrap_reference; | |
| 520 | 693 | pts_wrap_behavior = program->pts_wrap_behavior; | |
| 521 | 693 | break; | |
| 522 | } | ||
| 523 | 94 | program = av_find_program_from_stream(s, program, stream_index); | |
| 524 | } | ||
| 525 | |||
| 526 | // update every program with differing pts_wrap_reference | ||
| 527 | 787 | program = first_program; | |
| 528 |
2/2✓ Branch 0 taken 787 times.
✓ Branch 1 taken 787 times.
|
1574 | while (program) { |
| 529 |
2/2✓ Branch 0 taken 94 times.
✓ Branch 1 taken 693 times.
|
787 | if (program->pts_wrap_reference != pts_wrap_reference) { |
| 530 |
2/2✓ Branch 0 taken 143 times.
✓ Branch 1 taken 94 times.
|
237 | for (unsigned i = 0; i < program->nb_stream_indexes; i++) { |
| 531 | 143 | FFStream *const sti = ffstream(s->streams[program->stream_index[i]]); | |
| 532 | 143 | sti->pts_wrap_reference = pts_wrap_reference; | |
| 533 | 143 | sti->pts_wrap_behavior = pts_wrap_behavior; | |
| 534 | } | ||
| 535 | |||
| 536 | 94 | program->pts_wrap_reference = pts_wrap_reference; | |
| 537 | 94 | program->pts_wrap_behavior = pts_wrap_behavior; | |
| 538 | } | ||
| 539 | 787 | program = av_find_program_from_stream(s, program, stream_index); | |
| 540 | } | ||
| 541 | } | ||
| 542 | 1000 | return 1; | |
| 543 | } | ||
| 544 | |||
| 545 | 1130204 | static void update_timestamps(AVFormatContext *s, AVStream *st, AVPacket *pkt) | |
| 546 | { | ||
| 547 | 1130204 | FFStream *const sti = ffstream(st); | |
| 548 | |||
| 549 |
4/4✓ Branch 1 taken 1000 times.
✓ Branch 2 taken 1129204 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 999 times.
|
1130204 | if (update_wrap_reference(s, st, pkt->stream_index, pkt) && sti->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) { |
| 550 | // correct first time stamps to negative values | ||
| 551 |
1/2✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
|
1 | if (!is_relative(sti->first_dts)) |
| 552 | 1 | sti->first_dts = wrap_timestamp(st, sti->first_dts); | |
| 553 |
1/2✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
|
1 | if (!is_relative(st->start_time)) |
| 554 | 1 | st->start_time = wrap_timestamp(st, st->start_time); | |
| 555 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (!is_relative(sti->cur_dts)) |
| 556 | ✗ | sti->cur_dts = wrap_timestamp(st, sti->cur_dts); | |
| 557 | } | ||
| 558 | |||
| 559 | 1130204 | pkt->dts = wrap_timestamp(st, pkt->dts); | |
| 560 | 1130204 | pkt->pts = wrap_timestamp(st, pkt->pts); | |
| 561 | |||
| 562 | 1130204 | force_codec_ids(s, st); | |
| 563 | |||
| 564 | /* TODO: audio: time filter; video: frame reordering (pts != dts) */ | ||
| 565 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1130204 times.
|
1130204 | if (s->use_wallclock_as_timestamps) |
| 566 | ✗ | pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base); | |
| 567 | 1130204 | } | |
| 568 | |||
| 569 | /** | ||
| 570 | * Handle a new packet and either return it directly if possible and | ||
| 571 | * allow_passthrough is true or queue the packet (or drop the packet | ||
| 572 | * if corrupt). | ||
| 573 | * | ||
| 574 | * @return < 0 on error, 0 if the packet was passed through, | ||
| 575 | * 1 if it was queued or dropped | ||
| 576 | */ | ||
| 577 | 1130204 | static int handle_new_packet(AVFormatContext *s, AVPacket *pkt, int allow_passthrough) | |
| 578 | { | ||
| 579 | 1130204 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 580 | AVStream *st; | ||
| 581 | FFStream *sti; | ||
| 582 | int err; | ||
| 583 | |||
| 584 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1130204 times.
|
1130204 | av_assert0(pkt->stream_index < (unsigned)s->nb_streams && |
| 585 | "Invalid stream index.\n"); | ||
| 586 | |||
| 587 |
2/2✓ Branch 0 taken 206 times.
✓ Branch 1 taken 1129998 times.
|
1130204 | if (pkt->flags & AV_PKT_FLAG_CORRUPT) { |
| 588 | 412 | av_log(s, AV_LOG_WARNING, | |
| 589 | "Packet corrupt (stream = %d, dts = %s)%s.\n", | ||
| 590 | 206 | pkt->stream_index, av_ts2str(pkt->dts), | |
| 591 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 206 times.
|
206 | s->flags & AVFMT_FLAG_DISCARD_CORRUPT ? ", dropping it" : ""); |
| 592 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 206 times.
|
206 | if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) { |
| 593 | ✗ | av_packet_unref(pkt); | |
| 594 | ✗ | return 1; | |
| 595 | } | ||
| 596 | } | ||
| 597 | |||
| 598 | 1130204 | st = s->streams[pkt->stream_index]; | |
| 599 | 1130204 | sti = ffstream(st); | |
| 600 | |||
| 601 | 1130204 | update_timestamps(s, st, pkt); | |
| 602 | |||
| 603 |
6/6✓ Branch 0 taken 1112566 times.
✓ Branch 1 taken 17638 times.
✓ Branch 2 taken 1106365 times.
✓ Branch 3 taken 6201 times.
✓ Branch 4 taken 1106323 times.
✓ Branch 5 taken 42 times.
|
1130204 | if (sti->request_probe <= 0 && allow_passthrough && !fci->raw_packet_buffer.head) |
| 604 | 1106323 | return 0; | |
| 605 | |||
| 606 | 23881 | err = ff_packet_list_put(&fci->raw_packet_buffer, pkt, NULL, 0); | |
| 607 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 23881 times.
|
23881 | if (err < 0) { |
| 608 | ✗ | av_packet_unref(pkt); | |
| 609 | ✗ | return err; | |
| 610 | } | ||
| 611 | |||
| 612 | 23881 | pkt = &fci->raw_packet_buffer.tail->pkt; | |
| 613 | 23881 | fci->raw_packet_buffer_size += pkt->size; | |
| 614 | |||
| 615 | 23881 | err = probe_codec(s, st, pkt); | |
| 616 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 23881 times.
|
23881 | if (err < 0) |
| 617 | ✗ | return err; | |
| 618 | |||
| 619 | 23881 | return 1; | |
| 620 | } | ||
| 621 | |||
| 622 | 6201 | int ff_buffer_packet(AVFormatContext *s, AVPacket *pkt) | |
| 623 | { | ||
| 624 | 6201 | int err = handle_new_packet(s, pkt, 0); | |
| 625 | |||
| 626 | 6201 | return err < 0 ? err : 0; | |
| 627 | } | ||
| 628 | |||
| 629 | 1137380 | int ff_read_packet(AVFormatContext *s, AVPacket *pkt) | |
| 630 | { | ||
| 631 | 1137380 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 632 | int err; | ||
| 633 | |||
| 634 | #if FF_API_INIT_PACKET | ||
| 635 | FF_DISABLE_DEPRECATION_WARNINGS | ||
| 636 | 1137380 | pkt->data = NULL; | |
| 637 | 1137380 | pkt->size = 0; | |
| 638 | 1137380 | av_init_packet(pkt); | |
| 639 | FF_ENABLE_DEPRECATION_WARNINGS | ||
| 640 | #else | ||
| 641 | av_packet_unref(pkt); | ||
| 642 | #endif | ||
| 643 | |||
| 644 | 24146 | for (;;) { | |
| 645 | 1161526 | PacketListEntry *pktl = fci->raw_packet_buffer.head; | |
| 646 | |||
| 647 |
2/2✓ Branch 0 taken 41061 times.
✓ Branch 1 taken 1120465 times.
|
1161526 | if (pktl) { |
| 648 | 41061 | AVStream *const st = s->streams[pktl->pkt.stream_index]; | |
| 649 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 41061 times.
|
41061 | if (fci->raw_packet_buffer_size >= s->probesize) |
| 650 | ✗ | if ((err = probe_codec(s, st, NULL)) < 0) | |
| 651 | ✗ | return err; | |
| 652 |
2/2✓ Branch 1 taken 23937 times.
✓ Branch 2 taken 17124 times.
|
41061 | if (ffstream(st)->request_probe <= 0) { |
| 653 | 23937 | ff_packet_list_get(&fci->raw_packet_buffer, pkt); | |
| 654 | 23937 | fci->raw_packet_buffer_size -= pkt->size; | |
| 655 | 23937 | return 0; | |
| 656 | } | ||
| 657 | } | ||
| 658 | |||
| 659 | 1137589 | err = ffifmt(s->iformat)->read_packet(s, pkt); | |
| 660 |
2/2✓ Branch 0 taken 13586 times.
✓ Branch 1 taken 1124003 times.
|
1137589 | if (err < 0) { |
| 661 | 13586 | av_packet_unref(pkt); | |
| 662 | |||
| 663 | /* Some demuxers return FFERROR_REDO when they consume | ||
| 664 | data and discard it (ignored streams, junk, extradata). | ||
| 665 | We must re-call the demuxer to get the real packet. */ | ||
| 666 |
2/2✓ Branch 0 taken 6449 times.
✓ Branch 1 taken 7137 times.
|
13586 | if (err == FFERROR_REDO) |
| 667 | 6449 | continue; | |
| 668 |
3/4✓ Branch 0 taken 17 times.
✓ Branch 1 taken 7120 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 17 times.
|
7137 | if (!pktl || err == AVERROR(EAGAIN)) |
| 669 | 7120 | return err; | |
| 670 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 17 times.
|
34 | for (unsigned i = 0; i < s->nb_streams; i++) { |
| 671 | 17 | AVStream *const st = s->streams[i]; | |
| 672 | 17 | FFStream *const sti = ffstream(st); | |
| 673 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
17 | if (sti->probe_packets || sti->request_probe > 0) |
| 674 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 17 times.
|
17 | if ((err = probe_codec(s, st, NULL)) < 0) |
| 675 | ✗ | return err; | |
| 676 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
|
17 | av_assert0(sti->request_probe <= 0); |
| 677 | } | ||
| 678 | 17 | continue; | |
| 679 | } | ||
| 680 | |||
| 681 | 1124003 | err = av_packet_make_refcounted(pkt); | |
| 682 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1124003 times.
|
1124003 | if (err < 0) { |
| 683 | ✗ | av_packet_unref(pkt); | |
| 684 | ✗ | return err; | |
| 685 | } | ||
| 686 | |||
| 687 | 1124003 | err = handle_new_packet(s, pkt, 1); | |
| 688 |
2/2✓ Branch 0 taken 1106323 times.
✓ Branch 1 taken 17680 times.
|
1124003 | if (err <= 0) /* Error or passthrough */ |
| 689 | 1106323 | return err; | |
| 690 | } | ||
| 691 | } | ||
| 692 | |||
| 693 | /** | ||
| 694 | * Return the frame duration in seconds. Return 0 if not available. | ||
| 695 | */ | ||
| 696 | 333747 | static void compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, | |
| 697 | AVStream *st, AVCodecParserContext *pc, | ||
| 698 | AVPacket *pkt) | ||
| 699 | { | ||
| 700 | 333747 | FFStream *const sti = ffstream(st); | |
| 701 | 333747 | AVRational codec_framerate = sti->avctx->framerate; | |
| 702 | int frame_size, sample_rate; | ||
| 703 | |||
| 704 | 333747 | *pnum = 0; | |
| 705 | 333747 | *pden = 0; | |
| 706 |
3/3✓ Branch 0 taken 227699 times.
✓ Branch 1 taken 104456 times.
✓ Branch 2 taken 1592 times.
|
333747 | switch (st->codecpar->codec_type) { |
| 707 | 227699 | case AVMEDIA_TYPE_VIDEO: | |
| 708 |
6/6✓ Branch 0 taken 196603 times.
✓ Branch 1 taken 31096 times.
✓ Branch 2 taken 43284 times.
✓ Branch 3 taken 153319 times.
✓ Branch 4 taken 31039 times.
✓ Branch 5 taken 12245 times.
|
227699 | if (st->r_frame_rate.num && (!pc || !codec_framerate.num)) { |
| 709 | 184358 | *pnum = st->r_frame_rate.den; | |
| 710 | 184358 | *pden = st->r_frame_rate.num; | |
| 711 |
2/2✓ Branch 0 taken 24451 times.
✓ Branch 1 taken 18890 times.
|
43341 | } else if ((s->iformat->flags & AVFMT_NOTIMESTAMPS) && |
| 712 |
2/2✓ Branch 0 taken 15029 times.
✓ Branch 1 taken 9422 times.
|
24451 | !codec_framerate.num && |
| 713 |
3/4✓ Branch 0 taken 15027 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 15027 times.
✗ Branch 3 not taken.
|
15029 | st->avg_frame_rate.num && st->avg_frame_rate.den) { |
| 714 | 15027 | *pnum = st->avg_frame_rate.den; | |
| 715 | 15027 | *pden = st->avg_frame_rate.num; | |
| 716 |
2/2✓ Branch 0 taken 9168 times.
✓ Branch 1 taken 19146 times.
|
28314 | } else if (st->time_base.num * 1000LL > st->time_base.den) { |
| 717 | 9168 | *pnum = st->time_base.num; | |
| 718 | 9168 | *pden = st->time_base.den; | |
| 719 |
2/2✓ Branch 0 taken 19121 times.
✓ Branch 1 taken 25 times.
|
19146 | } else if (codec_framerate.den * 1000LL > codec_framerate.num) { |
| 720 | 57363 | int ticks_per_frame = (sti->codec_desc && | |
| 721 |
3/4✓ Branch 0 taken 19121 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13214 times.
✓ Branch 3 taken 5907 times.
|
19121 | (sti->codec_desc->props & AV_CODEC_PROP_FIELDS)) ? 2 : 1; |
| 722 | 19121 | av_reduce(pnum, pden, | |
| 723 | 19121 | codec_framerate.den, | |
| 724 | 19121 | codec_framerate.num * (int64_t)ticks_per_frame, | |
| 725 | INT_MAX); | ||
| 726 | |||
| 727 |
4/4✓ Branch 0 taken 17288 times.
✓ Branch 1 taken 1833 times.
✓ Branch 2 taken 12584 times.
✓ Branch 3 taken 4704 times.
|
19121 | if (pc && pc->repeat_pict) { |
| 728 | 12584 | av_reduce(pnum, pden, | |
| 729 | 12584 | (*pnum) * (1LL + pc->repeat_pict), | |
| 730 | 12584 | (*pden), | |
| 731 | INT_MAX); | ||
| 732 | } | ||
| 733 | /* If this codec can be interlaced or progressive then we need | ||
| 734 | * a parser to compute duration of a packet. Thus if we have | ||
| 735 | * no parser in such case leave duration undefined. */ | ||
| 736 |
1/2✓ Branch 0 taken 19121 times.
✗ Branch 1 not taken.
|
19121 | if (sti->codec_desc && |
| 737 |
3/4✓ Branch 0 taken 13214 times.
✓ Branch 1 taken 5907 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 13214 times.
|
19121 | (sti->codec_desc->props & AV_CODEC_PROP_FIELDS) && !pc) |
| 738 | ✗ | *pnum = *pden = 0; | |
| 739 | } | ||
| 740 | 227699 | break; | |
| 741 | 104456 | case AVMEDIA_TYPE_AUDIO: | |
| 742 |
2/2✓ Branch 0 taken 46358 times.
✓ Branch 1 taken 58098 times.
|
104456 | if (sti->avctx_inited) { |
| 743 | 46358 | frame_size = av_get_audio_frame_duration(sti->avctx, pkt->size); | |
| 744 | 46358 | sample_rate = sti->avctx->sample_rate; | |
| 745 | } else { | ||
| 746 | 58098 | frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size); | |
| 747 | 58098 | sample_rate = st->codecpar->sample_rate; | |
| 748 | } | ||
| 749 |
4/4✓ Branch 0 taken 99035 times.
✓ Branch 1 taken 5421 times.
✓ Branch 2 taken 99030 times.
✓ Branch 3 taken 5 times.
|
104456 | if (frame_size <= 0 || sample_rate <= 0) |
| 750 | break; | ||
| 751 | 99030 | *pnum = frame_size; | |
| 752 | 99030 | *pden = sample_rate; | |
| 753 | 99030 | break; | |
| 754 | 1592 | default: | |
| 755 | 1592 | break; | |
| 756 | } | ||
| 757 | 333747 | } | |
| 758 | |||
| 759 | 801968 | static int has_decode_delay_been_guessed(AVStream *st) | |
| 760 | { | ||
| 761 | 801968 | FFStream *const sti = ffstream(st); | |
| 762 |
2/2✓ Branch 0 taken 784328 times.
✓ Branch 1 taken 17640 times.
|
801968 | if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1; |
| 763 |
2/2✓ Branch 0 taken 6281 times.
✓ Branch 1 taken 11359 times.
|
17640 | if (!sti->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy |
| 764 | 6281 | return 1; | |
| 765 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 11359 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
|
11359 | av_assert0(sti->avctx->codec_id == AV_CODEC_ID_H264 || (sti->avctx->codec_id == AV_CODEC_ID_NONE && !avcodec_is_open(sti->avctx))); |
| 766 | #if CONFIG_H264_DECODER | ||
| 767 |
4/4✓ Branch 0 taken 6979 times.
✓ Branch 1 taken 4380 times.
✓ Branch 3 taken 6854 times.
✓ Branch 4 taken 125 times.
|
11359 | if (sti->avctx->has_b_frames && avcodec_is_open(sti->avctx) && |
| 768 |
2/2✓ Branch 1 taken 1703 times.
✓ Branch 2 taken 5151 times.
|
6854 | avpriv_h264_has_num_reorder_frames(sti->avctx) == sti->avctx->has_b_frames) |
| 769 | 1703 | return 1; | |
| 770 | #endif | ||
| 771 |
2/2✓ Branch 0 taken 9466 times.
✓ Branch 1 taken 190 times.
|
9656 | if (sti->avctx->has_b_frames < 3) |
| 772 | 9466 | return sti->nb_decoded_frames >= 7; | |
| 773 |
2/2✓ Branch 0 taken 36 times.
✓ Branch 1 taken 154 times.
|
190 | else if (sti->avctx->has_b_frames < 4) |
| 774 | 36 | return sti->nb_decoded_frames >= 18; | |
| 775 | else | ||
| 776 | 154 | return sti->nb_decoded_frames >= 20; | |
| 777 | } | ||
| 778 | |||
| 779 | 37345 | static PacketListEntry *get_next_pkt(AVFormatContext *s, AVStream *st, | |
| 780 | PacketListEntry *pktl) | ||
| 781 | { | ||
| 782 | 37345 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 783 | 37345 | FFFormatContext *const si = &fci->fc; | |
| 784 |
2/2✓ Branch 0 taken 35245 times.
✓ Branch 1 taken 2100 times.
|
37345 | if (pktl->next) |
| 785 | 35245 | return pktl->next; | |
| 786 |
2/2✓ Branch 0 taken 2068 times.
✓ Branch 1 taken 32 times.
|
2100 | if (pktl == si->packet_buffer.tail) |
| 787 | 2068 | return fci->parse_queue.head; | |
| 788 | 32 | return NULL; | |
| 789 | } | ||
| 790 | |||
| 791 | 594223 | static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) | |
| 792 | { | ||
| 793 | 594223 | FFStream *const sti = ffstream(st); | |
| 794 | 1775030 | int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 && | |
| 795 |
4/4✓ Branch 0 taken 586584 times.
✓ Branch 1 taken 7639 times.
✓ Branch 2 taken 584959 times.
✓ Branch 3 taken 1625 times.
|
1179182 | st->codecpar->codec_id != AV_CODEC_ID_HEVC && |
| 796 |
2/2✓ Branch 0 taken 584743 times.
✓ Branch 1 taken 216 times.
|
584959 | st->codecpar->codec_id != AV_CODEC_ID_VVC; |
| 797 | |||
| 798 |
2/2✓ Branch 0 taken 9480 times.
✓ Branch 1 taken 584743 times.
|
594223 | if (!onein_oneout) { |
| 799 | 9480 | int delay = sti->avctx->has_b_frames; | |
| 800 | |||
| 801 |
2/2✓ Branch 0 taken 1390 times.
✓ Branch 1 taken 8090 times.
|
9480 | if (dts == AV_NOPTS_VALUE) { |
| 802 | 1390 | int64_t best_score = INT64_MAX; | |
| 803 |
2/2✓ Branch 0 taken 1701 times.
✓ Branch 1 taken 1390 times.
|
3091 | for (int i = 0; i < delay; i++) { |
| 804 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1701 times.
|
1701 | if (sti->pts_reorder_error_count[i]) { |
| 805 | ✗ | int64_t score = sti->pts_reorder_error[i] / sti->pts_reorder_error_count[i]; | |
| 806 | ✗ | if (score < best_score) { | |
| 807 | ✗ | best_score = score; | |
| 808 | ✗ | dts = pts_buffer[i]; | |
| 809 | } | ||
| 810 | } | ||
| 811 | } | ||
| 812 | } else { | ||
| 813 |
2/2✓ Branch 0 taken 14454 times.
✓ Branch 1 taken 8090 times.
|
22544 | for (int i = 0; i < delay; i++) { |
| 814 |
2/2✓ Branch 0 taken 13487 times.
✓ Branch 1 taken 967 times.
|
14454 | if (pts_buffer[i] != AV_NOPTS_VALUE) { |
| 815 | #define ABSDIFF(a,b) (((a) < (b)) ? (b) - (uint64_t)(a) : ((a) - (uint64_t)(b))) | ||
| 816 |
2/2✓ Branch 0 taken 4146 times.
✓ Branch 1 taken 9341 times.
|
13487 | uint64_t diff = ABSDIFF(pts_buffer[i], dts); |
| 817 | |||
| 818 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13487 times.
|
13487 | if (diff > INT64_MAX - sti->pts_reorder_error[i]) { |
| 819 | ✗ | diff = INT64_MAX; | |
| 820 | } else | ||
| 821 | 13487 | diff += sti->pts_reorder_error[i]; | |
| 822 | |||
| 823 | 13487 | sti->pts_reorder_error[i] = diff; | |
| 824 | 13487 | sti->pts_reorder_error_count[i]++; | |
| 825 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 13484 times.
|
13487 | if (sti->pts_reorder_error_count[i] > 250) { |
| 826 | 3 | sti->pts_reorder_error[i] >>= 1; | |
| 827 | 3 | sti->pts_reorder_error_count[i] >>= 1; | |
| 828 | } | ||
| 829 | } | ||
| 830 | } | ||
| 831 | } | ||
| 832 | } | ||
| 833 | |||
| 834 |
2/2✓ Branch 0 taken 1765 times.
✓ Branch 1 taken 592458 times.
|
594223 | if (dts == AV_NOPTS_VALUE) |
| 835 | 1765 | dts = pts_buffer[0]; | |
| 836 | |||
| 837 | 594223 | return dts; | |
| 838 | } | ||
| 839 | |||
| 840 | /** | ||
| 841 | * Updates the dts of packets of a stream in pkt_buffer, by re-ordering the pts | ||
| 842 | * of the packets in a window. | ||
| 843 | */ | ||
| 844 | 6482 | static void update_dts_from_pts(AVFormatContext *s, int stream_index, | |
| 845 | PacketListEntry *pkt_buffer) | ||
| 846 | { | ||
| 847 | 6482 | AVStream *const st = s->streams[stream_index]; | |
| 848 | 6482 | int delay = ffstream(st)->avctx->has_b_frames; | |
| 849 | |||
| 850 | int64_t pts_buffer[MAX_REORDER_DELAY+1]; | ||
| 851 | |||
| 852 |
2/2✓ Branch 0 taken 110194 times.
✓ Branch 1 taken 6482 times.
|
116676 | for (int i = 0; i < MAX_REORDER_DELAY + 1; i++) |
| 853 | 110194 | pts_buffer[i] = AV_NOPTS_VALUE; | |
| 854 | |||
| 855 |
2/2✓ Branch 1 taken 5711 times.
✓ Branch 2 taken 6482 times.
|
12193 | for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) { |
| 856 |
2/2✓ Branch 0 taken 5024 times.
✓ Branch 1 taken 687 times.
|
5711 | if (pkt_buffer->pkt.stream_index != stream_index) |
| 857 | 5024 | continue; | |
| 858 | |||
| 859 |
3/4✓ Branch 0 taken 589 times.
✓ Branch 1 taken 98 times.
✓ Branch 2 taken 589 times.
✗ Branch 3 not taken.
|
687 | if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) { |
| 860 | 589 | pts_buffer[0] = pkt_buffer->pkt.pts; | |
| 861 |
4/4✓ Branch 0 taken 419 times.
✓ Branch 1 taken 424 times.
✓ Branch 2 taken 254 times.
✓ Branch 3 taken 165 times.
|
843 | for (int i = 0; i < delay && pts_buffer[i] > pts_buffer[i + 1]; i++) |
| 862 | 254 | FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]); | |
| 863 | |||
| 864 | 589 | pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts); | |
| 865 | } | ||
| 866 | } | ||
| 867 | 6482 | } | |
| 868 | |||
| 869 | 636188 | static void update_initial_timestamps(AVFormatContext *s, int stream_index, | |
| 870 | int64_t dts, int64_t pts, AVPacket *pkt) | ||
| 871 | { | ||
| 872 | 636188 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 873 | 636188 | FFFormatContext *const si = &fci->fc; | |
| 874 | 636188 | AVStream *const st = s->streams[stream_index]; | |
| 875 | 636188 | FFStream *const sti = ffstream(st); | |
| 876 |
2/2✓ Branch 0 taken 190403 times.
✓ Branch 1 taken 445785 times.
|
636188 | PacketListEntry *pktl = si->packet_buffer.head ? si->packet_buffer.head : fci->parse_queue.head; |
| 877 | |||
| 878 | uint64_t shift; | ||
| 879 | |||
| 880 |
4/4✓ Branch 0 taken 228620 times.
✓ Branch 1 taken 407568 times.
✓ Branch 2 taken 6557 times.
✓ Branch 3 taken 222063 times.
|
636188 | if (sti->first_dts != AV_NOPTS_VALUE || |
| 881 | 6557 | dts == AV_NOPTS_VALUE || | |
| 882 |
1/2✓ Branch 0 taken 6557 times.
✗ Branch 1 not taken.
|
6557 | sti->cur_dts == AV_NOPTS_VALUE || |
| 883 |
1/2✓ Branch 0 taken 6557 times.
✗ Branch 1 not taken.
|
6557 | sti->cur_dts < INT_MIN + RELATIVE_TS_BASE || |
| 884 |
2/4✓ Branch 0 taken 6557 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6557 times.
|
13114 | dts < INT_MIN + (sti->cur_dts - RELATIVE_TS_BASE) || |
| 885 | 6557 | is_relative(dts)) | |
| 886 | 629631 | return; | |
| 887 | |||
| 888 | 6557 | sti->first_dts = dts - (sti->cur_dts - RELATIVE_TS_BASE); | |
| 889 | 6557 | sti->cur_dts = dts; | |
| 890 | 6557 | shift = (uint64_t)sti->first_dts - RELATIVE_TS_BASE; | |
| 891 | |||
| 892 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 6557 times.
|
6557 | if (is_relative(pts)) |
| 893 | ✗ | pts += shift; | |
| 894 | |||
| 895 |
2/2✓ Branch 1 taken 5449 times.
✓ Branch 2 taken 6557 times.
|
12006 | for (PacketListEntry *pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) { |
| 896 |
2/2✓ Branch 0 taken 4955 times.
✓ Branch 1 taken 494 times.
|
5449 | if (pktl_it->pkt.stream_index != stream_index) |
| 897 | 4955 | continue; | |
| 898 |
2/2✓ Branch 1 taken 207 times.
✓ Branch 2 taken 287 times.
|
494 | if (is_relative(pktl_it->pkt.pts)) |
| 899 | 207 | pktl_it->pkt.pts += shift; | |
| 900 | |||
| 901 |
2/2✓ Branch 1 taken 235 times.
✓ Branch 2 taken 259 times.
|
494 | if (is_relative(pktl_it->pkt.dts)) |
| 902 | 235 | pktl_it->pkt.dts += shift; | |
| 903 | |||
| 904 |
4/4✓ Branch 0 taken 81 times.
✓ Branch 1 taken 413 times.
✓ Branch 2 taken 52 times.
✓ Branch 3 taken 29 times.
|
494 | if (st->start_time == AV_NOPTS_VALUE && pktl_it->pkt.pts != AV_NOPTS_VALUE) { |
| 905 | 52 | st->start_time = pktl_it->pkt.pts; | |
| 906 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 50 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
|
52 | if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate) |
| 907 | 2 | st->start_time = av_sat_add64(st->start_time, av_rescale_q(sti->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base)); | |
| 908 | } | ||
| 909 | } | ||
| 910 | |||
| 911 |
2/2✓ Branch 1 taken 6463 times.
✓ Branch 2 taken 94 times.
|
6557 | if (has_decode_delay_been_guessed(st)) |
| 912 | 6463 | update_dts_from_pts(s, stream_index, pktl); | |
| 913 | |||
| 914 |
2/2✓ Branch 0 taken 1859 times.
✓ Branch 1 taken 4698 times.
|
6557 | if (st->start_time == AV_NOPTS_VALUE) { |
| 915 |
3/4✓ Branch 0 taken 1309 times.
✓ Branch 1 taken 550 times.
✓ Branch 2 taken 1309 times.
✗ Branch 3 not taken.
|
1859 | if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) { |
| 916 | 1859 | st->start_time = pts; | |
| 917 | } | ||
| 918 |
4/4✓ Branch 0 taken 550 times.
✓ Branch 1 taken 1309 times.
✓ Branch 2 taken 454 times.
✓ Branch 3 taken 96 times.
|
1859 | if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate) |
| 919 | 454 | st->start_time = av_sat_add64(st->start_time, av_rescale_q(sti->skip_samples, (AVRational){1, st->codecpar->sample_rate}, st->time_base)); | |
| 920 | } | ||
| 921 | } | ||
| 922 | |||
| 923 | 276485 | static void update_initial_durations(AVFormatContext *s, AVStream *st, | |
| 924 | int stream_index, int64_t duration) | ||
| 925 | { | ||
| 926 | 276485 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 927 | 276485 | FFFormatContext *const si = &fci->fc; | |
| 928 | 276485 | FFStream *const sti = ffstream(st); | |
| 929 |
2/2✓ Branch 0 taken 187145 times.
✓ Branch 1 taken 89340 times.
|
276485 | PacketListEntry *pktl = si->packet_buffer.head ? si->packet_buffer.head : fci->parse_queue.head; |
| 930 | 276485 | int64_t cur_dts = RELATIVE_TS_BASE; | |
| 931 | |||
| 932 |
2/2✓ Branch 0 taken 134775 times.
✓ Branch 1 taken 141710 times.
|
276485 | if (sti->first_dts != AV_NOPTS_VALUE) { |
| 933 |
2/2✓ Branch 0 taken 130993 times.
✓ Branch 1 taken 3782 times.
|
134775 | if (sti->update_initial_durations_done) |
| 934 | 130993 | return; | |
| 935 | 3782 | sti->update_initial_durations_done = 1; | |
| 936 | 3782 | cur_dts = sti->first_dts; | |
| 937 |
1/2✓ Branch 1 taken 5627 times.
✗ Branch 2 not taken.
|
5627 | for (; pktl; pktl = get_next_pkt(s, st, pktl)) { |
| 938 |
2/2✓ Branch 0 taken 3798 times.
✓ Branch 1 taken 1829 times.
|
5627 | if (pktl->pkt.stream_index == stream_index) { |
| 939 |
2/2✓ Branch 0 taken 3666 times.
✓ Branch 1 taken 132 times.
|
3798 | if (pktl->pkt.pts != pktl->pkt.dts || |
| 940 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 3650 times.
|
3666 | pktl->pkt.dts != AV_NOPTS_VALUE || |
| 941 |
1/2✓ Branch 0 taken 16 times.
✗ Branch 1 not taken.
|
16 | pktl->pkt.duration) |
| 942 | break; | ||
| 943 | 16 | cur_dts -= duration; | |
| 944 | } | ||
| 945 | } | ||
| 946 |
3/4✓ Branch 0 taken 3782 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 41 times.
✓ Branch 3 taken 3741 times.
|
3782 | if (pktl && pktl->pkt.dts != sti->first_dts) { |
| 947 | 41 | av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %"PRId64") in the queue\n", | |
| 948 | 41 | av_ts2str(sti->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration); | |
| 949 | 41 | return; | |
| 950 | } | ||
| 951 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3741 times.
|
3741 | if (!pktl) { |
| 952 | ✗ | av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(sti->first_dts)); | |
| 953 | ✗ | return; | |
| 954 | } | ||
| 955 |
2/2✓ Branch 0 taken 3717 times.
✓ Branch 1 taken 24 times.
|
3741 | pktl = si->packet_buffer.head ? si->packet_buffer.head : fci->parse_queue.head; |
| 956 | 3741 | sti->first_dts = cur_dts; | |
| 957 |
2/2✓ Branch 0 taken 116389 times.
✓ Branch 1 taken 25321 times.
|
141710 | } else if (sti->cur_dts != RELATIVE_TS_BASE) |
| 958 | 116389 | return; | |
| 959 | |||
| 960 |
2/2✓ Branch 1 taken 52698 times.
✓ Branch 2 taken 704 times.
|
53402 | for (; pktl; pktl = get_next_pkt(s, st, pktl)) { |
| 961 |
2/2✓ Branch 0 taken 24172 times.
✓ Branch 1 taken 28526 times.
|
52698 | if (pktl->pkt.stream_index != stream_index) |
| 962 | 24172 | continue; | |
| 963 |
2/2✓ Branch 0 taken 780 times.
✓ Branch 1 taken 27746 times.
|
28526 | if ((pktl->pkt.pts == pktl->pkt.dts || |
| 964 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 766 times.
|
780 | pktl->pkt.pts == AV_NOPTS_VALUE) && |
| 965 |
2/2✓ Branch 0 taken 3798 times.
✓ Branch 1 taken 23962 times.
|
27760 | (pktl->pkt.dts == AV_NOPTS_VALUE || |
| 966 |
2/2✓ Branch 0 taken 179 times.
✓ Branch 1 taken 3619 times.
|
3798 | pktl->pkt.dts == sti->first_dts || |
| 967 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 177 times.
|
179 | pktl->pkt.dts == RELATIVE_TS_BASE) && |
| 968 |
2/2✓ Branch 0 taken 168 times.
✓ Branch 1 taken 27415 times.
|
27583 | !pktl->pkt.duration && |
| 969 |
1/2✓ Branch 1 taken 168 times.
✗ Branch 2 not taken.
|
168 | av_sat_add64(cur_dts, duration) == cur_dts + (uint64_t)duration |
| 970 | ) { | ||
| 971 | 168 | pktl->pkt.dts = cur_dts; | |
| 972 |
2/2✓ Branch 0 taken 152 times.
✓ Branch 1 taken 16 times.
|
168 | if (!sti->avctx->has_b_frames) |
| 973 | 152 | pktl->pkt.pts = cur_dts; | |
| 974 | 168 | pktl->pkt.duration = duration; | |
| 975 | } else | ||
| 976 | break; | ||
| 977 | 168 | cur_dts = pktl->pkt.dts + pktl->pkt.duration; | |
| 978 | } | ||
| 979 |
2/2✓ Branch 0 taken 704 times.
✓ Branch 1 taken 28358 times.
|
29062 | if (!pktl) |
| 980 | 704 | sti->cur_dts = cur_dts; | |
| 981 | } | ||
| 982 | |||
| 983 | 642521 | static void compute_pkt_fields(AVFormatContext *s, AVStream *st, | |
| 984 | AVCodecParserContext *pc, AVPacket *pkt, | ||
| 985 | int64_t next_dts, int64_t next_pts) | ||
| 986 | { | ||
| 987 | 642521 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 988 | 642521 | FFFormatContext *const si = &fci->fc; | |
| 989 | 642521 | FFStream *const sti = ffstream(st); | |
| 990 | int num, den, presentation_delayed, delay; | ||
| 991 | int64_t offset; | ||
| 992 | AVRational duration; | ||
| 993 | 1892767 | int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 && | |
| 994 |
4/4✓ Branch 0 taken 607725 times.
✓ Branch 1 taken 34796 times.
✓ Branch 2 taken 593741 times.
✓ Branch 3 taken 13984 times.
|
1236262 | st->codecpar->codec_id != AV_CODEC_ID_HEVC && |
| 995 |
2/2✓ Branch 0 taken 590378 times.
✓ Branch 1 taken 3363 times.
|
593741 | st->codecpar->codec_id != AV_CODEC_ID_VVC; |
| 996 | |||
| 997 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 642521 times.
|
642521 | if (s->flags & AVFMT_FLAG_NOFILLIN) |
| 998 | ✗ | return; | |
| 999 | |||
| 1000 |
4/4✓ Branch 0 taken 252176 times.
✓ Branch 1 taken 390345 times.
✓ Branch 2 taken 75322 times.
✓ Branch 3 taken 176854 times.
|
642521 | if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) { |
| 1001 |
4/4✓ Branch 0 taken 43861 times.
✓ Branch 1 taken 31461 times.
✓ Branch 2 taken 42641 times.
✓ Branch 3 taken 1220 times.
|
75322 | if (pkt->dts == pkt->pts && sti->last_dts_for_order_check != AV_NOPTS_VALUE) { |
| 1002 |
2/2✓ Branch 0 taken 42632 times.
✓ Branch 1 taken 9 times.
|
42641 | if (sti->last_dts_for_order_check <= pkt->dts) { |
| 1003 | 42632 | sti->dts_ordered++; | |
| 1004 | } else { | ||
| 1005 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6 times.
|
9 | av_log(s, sti->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING, |
| 1006 | "DTS %"PRIi64" < %"PRIi64" out of order\n", | ||
| 1007 | pkt->dts, | ||
| 1008 | sti->last_dts_for_order_check); | ||
| 1009 | 9 | sti->dts_misordered++; | |
| 1010 | } | ||
| 1011 |
2/2✓ Branch 0 taken 29 times.
✓ Branch 1 taken 42612 times.
|
42641 | if (sti->dts_ordered + sti->dts_misordered > 250) { |
| 1012 | 29 | sti->dts_ordered >>= 1; | |
| 1013 | 29 | sti->dts_misordered >>= 1; | |
| 1014 | } | ||
| 1015 | } | ||
| 1016 | |||
| 1017 | 75322 | sti->last_dts_for_order_check = pkt->dts; | |
| 1018 |
4/4✓ Branch 0 taken 37 times.
✓ Branch 1 taken 75285 times.
✓ Branch 2 taken 20 times.
✓ Branch 3 taken 17 times.
|
75322 | if (sti->dts_ordered < 8 * sti->dts_misordered && pkt->dts == pkt->pts) |
| 1019 | 20 | pkt->dts = AV_NOPTS_VALUE; | |
| 1020 | } | ||
| 1021 | |||
| 1022 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 642521 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
642521 | if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE) |
| 1023 | ✗ | pkt->dts = AV_NOPTS_VALUE; | |
| 1024 | |||
| 1025 |
4/4✓ Branch 0 taken 238423 times.
✓ Branch 1 taken 404098 times.
✓ Branch 2 taken 29012 times.
✓ Branch 3 taken 209411 times.
|
642521 | if (pc && pc->pict_type == AV_PICTURE_TYPE_B |
| 1026 |
2/2✓ Branch 0 taken 82 times.
✓ Branch 1 taken 28930 times.
|
29012 | && !sti->avctx->has_b_frames) |
| 1027 | //FIXME Set low_delay = 0 when has_b_frames = 1 | ||
| 1028 | 82 | sti->avctx->has_b_frames = 1; | |
| 1029 | |||
| 1030 | /* do we have a video B-frame ? */ | ||
| 1031 | 642521 | delay = sti->avctx->has_b_frames; | |
| 1032 | 642521 | presentation_delayed = 0; | |
| 1033 | |||
| 1034 | /* XXX: need has_b_frame, but cannot get it if the codec is | ||
| 1035 | * not initialized */ | ||
| 1036 |
4/4✓ Branch 0 taken 49166 times.
✓ Branch 1 taken 593355 times.
✓ Branch 2 taken 44485 times.
✓ Branch 3 taken 4681 times.
|
642521 | if (delay && |
| 1037 |
2/2✓ Branch 0 taken 15473 times.
✓ Branch 1 taken 29012 times.
|
44485 | pc && pc->pict_type != AV_PICTURE_TYPE_B) |
| 1038 | 15473 | presentation_delayed = 1; | |
| 1039 | |||
| 1040 |
4/4✓ Branch 0 taken 351100 times.
✓ Branch 1 taken 291421 times.
✓ Branch 2 taken 171516 times.
✓ Branch 3 taken 179584 times.
|
642521 | if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && |
| 1041 |
3/4✓ Branch 0 taken 30654 times.
✓ Branch 1 taken 140862 times.
✓ Branch 2 taken 30654 times.
✗ Branch 3 not taken.
|
171516 | st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) && |
| 1042 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 30654 times.
|
30654 | pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) { |
| 1043 | ✗ | if (is_relative(sti->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > sti->cur_dts) { | |
| 1044 | ✗ | pkt->dts -= 1LL << st->pts_wrap_bits; | |
| 1045 | } else | ||
| 1046 | ✗ | pkt->pts += 1LL << st->pts_wrap_bits; | |
| 1047 | } | ||
| 1048 | |||
| 1049 | /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg). | ||
| 1050 | * We take the conservative approach and discard both. | ||
| 1051 | * Note: If this is misbehaving for an H.264 file, then possibly | ||
| 1052 | * presentation_delayed is not set correctly. */ | ||
| 1053 |
4/4✓ Branch 0 taken 31614 times.
✓ Branch 1 taken 610907 times.
✓ Branch 2 taken 25879 times.
✓ Branch 3 taken 5735 times.
|
642521 | if (delay == 1 && pkt->dts == pkt->pts && |
| 1054 |
4/4✓ Branch 0 taken 6508 times.
✓ Branch 1 taken 19371 times.
✓ Branch 2 taken 628 times.
✓ Branch 3 taken 5880 times.
|
25879 | pkt->dts != AV_NOPTS_VALUE && presentation_delayed) { |
| 1055 | 628 | av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts); | |
| 1056 |
2/2✓ Branch 0 taken 293 times.
✓ Branch 1 taken 335 times.
|
628 | if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2") |
| 1057 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 271 times.
|
293 | && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism |
| 1058 | 22 | pkt->dts = AV_NOPTS_VALUE; | |
| 1059 | } | ||
| 1060 | |||
| 1061 | 642521 | duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base); | |
| 1062 |
2/2✓ Branch 0 taken 329806 times.
✓ Branch 1 taken 312715 times.
|
642521 | if (pkt->duration <= 0) { |
| 1063 | 329806 | compute_frame_duration(s, &num, &den, st, pc, pkt); | |
| 1064 |
3/4✓ Branch 0 taken 319906 times.
✓ Branch 1 taken 9900 times.
✓ Branch 2 taken 319906 times.
✗ Branch 3 not taken.
|
329806 | if (den && num) { |
| 1065 | 319906 | duration = (AVRational) {num, den}; | |
| 1066 | 319906 | pkt->duration = av_rescale_rnd(1, | |
| 1067 | 319906 | num * (int64_t) st->time_base.den, | |
| 1068 | 319906 | den * (int64_t) st->time_base.num, | |
| 1069 | AV_ROUND_DOWN); | ||
| 1070 | } | ||
| 1071 | } | ||
| 1072 | |||
| 1073 |
6/6✓ Branch 0 taken 629799 times.
✓ Branch 1 taken 12722 times.
✓ Branch 2 taken 442654 times.
✓ Branch 3 taken 187145 times.
✓ Branch 4 taken 89340 times.
✓ Branch 5 taken 353314 times.
|
642521 | if (pkt->duration > 0 && (si->packet_buffer.head || fci->parse_queue.head)) |
| 1074 | 276485 | update_initial_durations(s, st, pkt->stream_index, pkt->duration); | |
| 1075 | |||
| 1076 | /* Correct timestamps with byte offset if demuxers only have timestamps | ||
| 1077 | * on packet boundaries */ | ||
| 1078 |
5/6✓ Branch 0 taken 238423 times.
✓ Branch 1 taken 404098 times.
✓ Branch 2 taken 961 times.
✓ Branch 3 taken 237462 times.
✓ Branch 4 taken 961 times.
✗ Branch 5 not taken.
|
642521 | if (pc && sti->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) { |
| 1079 | /* this will estimate bitrate based on this frame's duration and size */ | ||
| 1080 | 961 | offset = av_rescale(pc->offset, pkt->duration, pkt->size); | |
| 1081 |
2/2✓ Branch 0 taken 576 times.
✓ Branch 1 taken 385 times.
|
961 | if (pkt->pts != AV_NOPTS_VALUE) |
| 1082 | 576 | pkt->pts += offset; | |
| 1083 |
2/2✓ Branch 0 taken 121 times.
✓ Branch 1 taken 840 times.
|
961 | if (pkt->dts != AV_NOPTS_VALUE) |
| 1084 | 121 | pkt->dts += offset; | |
| 1085 | } | ||
| 1086 | |||
| 1087 | /* This may be redundant, but it should not hurt. */ | ||
| 1088 |
2/2✓ Branch 0 taken 201986 times.
✓ Branch 1 taken 440535 times.
|
642521 | if (pkt->dts != AV_NOPTS_VALUE && |
| 1089 |
2/2✓ Branch 0 taken 171494 times.
✓ Branch 1 taken 30492 times.
|
201986 | pkt->pts != AV_NOPTS_VALUE && |
| 1090 |
2/2✓ Branch 0 taken 6272 times.
✓ Branch 1 taken 165222 times.
|
171494 | pkt->pts > pkt->dts) |
| 1091 | 6272 | presentation_delayed = 1; | |
| 1092 | |||
| 1093 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 642521 times.
|
642521 | if (s->debug & AV_FDEBUG_TS) |
| 1094 | ✗ | av_log(s, AV_LOG_DEBUG, | |
| 1095 | "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%"PRId64" delay:%d onein_oneout:%d\n", | ||
| 1096 | ✗ | presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(sti->cur_dts), | |
| 1097 | pkt->stream_index, pc, pkt->duration, delay, onein_oneout); | ||
| 1098 | |||
| 1099 | /* Interpolate PTS and DTS if they are not present. We skip H264 | ||
| 1100 | * currently because delay and has_b_frames are not reliably set. */ | ||
| 1101 |
8/8✓ Branch 0 taken 49166 times.
✓ Branch 1 taken 593355 times.
✓ Branch 2 taken 31614 times.
✓ Branch 3 taken 17552 times.
✓ Branch 4 taken 27842 times.
✓ Branch 5 taken 3772 times.
✓ Branch 6 taken 586619 times.
✓ Branch 7 taken 34578 times.
|
642521 | if ((delay == 0 || (delay == 1 && pc)) && |
| 1102 | onein_oneout) { | ||
| 1103 |
2/2✓ Branch 0 taken 5879 times.
✓ Branch 1 taken 580740 times.
|
586619 | if (presentation_delayed) { |
| 1104 | /* DTS = decompression timestamp */ | ||
| 1105 | /* PTS = presentation timestamp */ | ||
| 1106 |
2/2✓ Branch 0 taken 2843 times.
✓ Branch 1 taken 3036 times.
|
5879 | if (pkt->dts == AV_NOPTS_VALUE) |
| 1107 | 2843 | pkt->dts = sti->last_IP_pts; | |
| 1108 | 5879 | update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); | |
| 1109 |
2/2✓ Branch 0 taken 2506 times.
✓ Branch 1 taken 3373 times.
|
5879 | if (pkt->dts == AV_NOPTS_VALUE) |
| 1110 | 2506 | pkt->dts = sti->cur_dts; | |
| 1111 | |||
| 1112 | /* This is tricky: the dts must be incremented by the duration | ||
| 1113 | * of the frame we are displaying, i.e. the last I- or P-frame. */ | ||
| 1114 |
3/4✓ Branch 0 taken 386 times.
✓ Branch 1 taken 5493 times.
✓ Branch 2 taken 386 times.
✗ Branch 3 not taken.
|
5879 | if (sti->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX) |
| 1115 | 386 | sti->last_IP_duration = pkt->duration; | |
| 1116 |
1/2✓ Branch 0 taken 5879 times.
✗ Branch 1 not taken.
|
5879 | if (pkt->dts != AV_NOPTS_VALUE) |
| 1117 | 5879 | sti->cur_dts = av_sat_add64(pkt->dts, sti->last_IP_duration); | |
| 1118 |
1/2✓ Branch 0 taken 5879 times.
✗ Branch 1 not taken.
|
5879 | if (pkt->dts != AV_NOPTS_VALUE && |
| 1119 |
2/2✓ Branch 0 taken 3270 times.
✓ Branch 1 taken 2609 times.
|
5879 | pkt->pts == AV_NOPTS_VALUE && |
| 1120 |
2/2✓ Branch 0 taken 3268 times.
✓ Branch 1 taken 2 times.
|
3270 | sti->last_IP_duration > 0 && |
| 1121 |
4/4✓ Branch 0 taken 781 times.
✓ Branch 1 taken 2487 times.
✓ Branch 2 taken 775 times.
✓ Branch 3 taken 6 times.
|
3268 | ((uint64_t)sti->cur_dts - (uint64_t)next_dts + 1) <= 2 && |
| 1122 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 764 times.
|
775 | next_dts != next_pts && |
| 1123 | next_pts != AV_NOPTS_VALUE) | ||
| 1124 | 11 | pkt->pts = next_dts; | |
| 1125 | |||
| 1126 |
1/2✓ Branch 0 taken 5879 times.
✗ Branch 1 not taken.
|
5879 | if ((uint64_t)pkt->duration <= INT32_MAX) |
| 1127 | 5879 | sti->last_IP_duration = pkt->duration; | |
| 1128 | 5879 | sti->last_IP_pts = pkt->pts; | |
| 1129 | /* Cannot compute PTS if not present (we can compute it only | ||
| 1130 | * by knowing the future. */ | ||
| 1131 |
2/2✓ Branch 0 taken 245762 times.
✓ Branch 1 taken 334978 times.
|
580740 | } else if (pkt->pts != AV_NOPTS_VALUE || |
| 1132 |
2/2✓ Branch 0 taken 216113 times.
✓ Branch 1 taken 29649 times.
|
245762 | pkt->dts != AV_NOPTS_VALUE || |
| 1133 |
2/2✓ Branch 0 taken 213539 times.
✓ Branch 1 taken 2574 times.
|
216113 | pkt->duration > 0 ) { |
| 1134 | |||
| 1135 | /* presentation is not delayed : PTS and DTS are the same */ | ||
| 1136 |
2/2✓ Branch 0 taken 243188 times.
✓ Branch 1 taken 334978 times.
|
578166 | if (pkt->pts == AV_NOPTS_VALUE) |
| 1137 | 243188 | pkt->pts = pkt->dts; | |
| 1138 | 578166 | update_initial_timestamps(s, pkt->stream_index, pkt->pts, | |
| 1139 | pkt->pts, pkt); | ||
| 1140 |
2/2✓ Branch 0 taken 213539 times.
✓ Branch 1 taken 364627 times.
|
578166 | if (pkt->pts == AV_NOPTS_VALUE) |
| 1141 | 213539 | pkt->pts = sti->cur_dts; | |
| 1142 | 578166 | pkt->dts = pkt->pts; | |
| 1143 |
3/4✓ Branch 0 taken 578166 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 578157 times.
✓ Branch 3 taken 9 times.
|
578166 | if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0) |
| 1144 | 578157 | sti->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1); | |
| 1145 | } | ||
| 1146 | } | ||
| 1147 | |||
| 1148 |
3/4✓ Branch 0 taken 594299 times.
✓ Branch 1 taken 48222 times.
✓ Branch 2 taken 594299 times.
✗ Branch 3 not taken.
|
642521 | if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) { |
| 1149 | 594299 | sti->pts_buffer[0] = pkt->pts; | |
| 1150 |
4/4✓ Branch 0 taken 25227 times.
✓ Branch 1 taken 587996 times.
✓ Branch 2 taken 18924 times.
✓ Branch 3 taken 6303 times.
|
613223 | for (int i = 0; i < delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++) |
| 1151 | 18924 | FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]); | |
| 1152 | |||
| 1153 |
2/2✓ Branch 1 taken 593634 times.
✓ Branch 2 taken 665 times.
|
594299 | if (has_decode_delay_been_guessed(st)) |
| 1154 | 593634 | pkt->dts = select_from_pts_buffer(st, sti->pts_buffer, pkt->dts); | |
| 1155 | } | ||
| 1156 | // We skipped it above so we try here. | ||
| 1157 |
2/2✓ Branch 0 taken 52143 times.
✓ Branch 1 taken 590378 times.
|
642521 | if (!onein_oneout) |
| 1158 | // This should happen on the first packet | ||
| 1159 | 52143 | update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); | |
| 1160 |
2/2✓ Branch 0 taken 9259 times.
✓ Branch 1 taken 633262 times.
|
642521 | if (pkt->dts > sti->cur_dts) |
| 1161 | 9259 | sti->cur_dts = pkt->dts; | |
| 1162 | |||
| 1163 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 642521 times.
|
642521 | if (s->debug & AV_FDEBUG_TS) |
| 1164 | ✗ | av_log(s, AV_LOG_DEBUG, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s st:%d (%d)\n", | |
| 1165 | ✗ | presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(sti->cur_dts), st->index, st->id); | |
| 1166 | |||
| 1167 | /* update flags */ | ||
| 1168 |
4/4✓ Branch 0 taken 642368 times.
✓ Branch 1 taken 153 times.
✓ Branch 3 taken 433942 times.
✓ Branch 4 taken 208426 times.
|
642521 | if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id)) |
| 1169 | 434095 | pkt->flags |= AV_PKT_FLAG_KEY; | |
| 1170 | } | ||
| 1171 | |||
| 1172 | /** | ||
| 1173 | * Parse a packet, add all split parts to parse_queue. | ||
| 1174 | * | ||
| 1175 | * @param pkt Packet to parse; must not be NULL. | ||
| 1176 | * @param flush Indicates whether to flush. If set, pkt must be blank. | ||
| 1177 | */ | ||
| 1178 | 720420 | static int parse_packet(AVFormatContext *s, AVPacket *pkt, | |
| 1179 | int stream_index, int flush) | ||
| 1180 | { | ||
| 1181 | 720420 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 1182 | 720420 | AVStream *st = s->streams[stream_index]; | |
| 1183 | 720420 | FFStream *const sti = ffstream(st); | |
| 1184 | 720420 | AVPacket *out_pkt = sti->parse_pkt; | |
| 1185 | 720420 | const AVPacketSideData *sd = NULL; | |
| 1186 | 720420 | const uint8_t *data = pkt->data; | |
| 1187 | 720420 | uint8_t *extradata = sti->avctx->extradata; | |
| 1188 | 720420 | int extradata_size = sti->avctx->extradata_size; | |
| 1189 | 720420 | int size = pkt->size; | |
| 1190 | 720420 | int ret = 0, got_output = flush, pkt_side_data_consumed = 0; | |
| 1191 | |||
| 1192 |
5/6✓ Branch 0 taken 2437 times.
✓ Branch 1 taken 717983 times.
✓ Branch 2 taken 164 times.
✓ Branch 3 taken 2273 times.
✓ Branch 4 taken 164 times.
✗ Branch 5 not taken.
|
720420 | if (!size && !flush && sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) { |
| 1193 | // preserve 0-size sync packets | ||
| 1194 | 164 | compute_pkt_fields(s, st, sti->parser, pkt, pkt->dts, pkt->pts); | |
| 1195 | |||
| 1196 | // Theora has valid 0-sized packets that need to be output | ||
| 1197 |
2/2✓ Branch 0 taken 148 times.
✓ Branch 1 taken 16 times.
|
164 | if (st->codecpar->codec_id == AV_CODEC_ID_THEORA) { |
| 1198 | 148 | ret = ff_packet_list_put(&fci->parse_queue, | |
| 1199 | pkt, NULL, 0); | ||
| 1200 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 148 times.
|
148 | if (ret < 0) |
| 1201 | ✗ | goto fail; | |
| 1202 | } | ||
| 1203 | } | ||
| 1204 | |||
| 1205 |
2/2✓ Branch 0 taken 27892 times.
✓ Branch 1 taken 692528 times.
|
720420 | if (pkt->side_data_elems) |
| 1206 | 27892 | sd = av_packet_side_data_get(pkt->side_data, pkt->side_data_elems, | |
| 1207 | AV_PKT_DATA_NEW_EXTRADATA); | ||
| 1208 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 720414 times.
|
720420 | if (sd) { |
| 1209 | av_assert1(size && !flush); | ||
| 1210 | |||
| 1211 | 6 | sti->avctx->extradata = sd->data; | |
| 1212 | 6 | sti->avctx->extradata_size = sd->size; | |
| 1213 | } | ||
| 1214 | |||
| 1215 |
6/6✓ Branch 0 taken 885939 times.
✓ Branch 1 taken 723952 times.
✓ Branch 2 taken 5805 times.
✓ Branch 3 taken 718147 times.
✓ Branch 4 taken 3532 times.
✓ Branch 5 taken 2273 times.
|
1609891 | while (size > 0 || (flush && got_output)) { |
| 1216 | 889471 | int64_t next_pts = pkt->pts; | |
| 1217 | 889471 | int64_t next_dts = pkt->dts; | |
| 1218 | int len; | ||
| 1219 | |||
| 1220 | 889471 | len = av_parser_parse2(sti->parser, sti->avctx, | |
| 1221 | &out_pkt->data, &out_pkt->size, data, size, | ||
| 1222 | pkt->pts, pkt->dts, pkt->pos); | ||
| 1223 | |||
| 1224 | 889471 | pkt->pts = pkt->dts = AV_NOPTS_VALUE; | |
| 1225 | 889471 | pkt->pos = -1; | |
| 1226 | /* increment read pointer */ | ||
| 1227 | av_assert1(data || !len); | ||
| 1228 |
2/2✓ Branch 0 taken 873658 times.
✓ Branch 1 taken 15813 times.
|
889471 | data = len ? data + len : data; |
| 1229 | 889471 | size -= len; | |
| 1230 | |||
| 1231 | 889471 | got_output = !!out_pkt->size; | |
| 1232 | |||
| 1233 |
4/4✓ Branch 0 taken 38475 times.
✓ Branch 1 taken 850996 times.
✓ Branch 2 taken 16561 times.
✓ Branch 3 taken 21914 times.
|
889471 | if (pkt->side_data && !out_pkt->side_data) { |
| 1234 | /* for the first iteration, side_data are simply moved to output. | ||
| 1235 | * in case of additional iterations, they are duplicated each time. */ | ||
| 1236 |
2/2✓ Branch 0 taken 10782 times.
✓ Branch 1 taken 5779 times.
|
16561 | if (!pkt_side_data_consumed) { |
| 1237 | 10782 | pkt_side_data_consumed = 1; | |
| 1238 | 10782 | out_pkt->side_data = pkt->side_data; | |
| 1239 | 10782 | out_pkt->side_data_elems = pkt->side_data_elems; | |
| 1240 |
2/2✓ Branch 0 taken 5779 times.
✓ Branch 1 taken 5779 times.
|
11558 | } else for (int i = 0; i < pkt->side_data_elems; i++) { |
| 1241 | 5779 | const AVPacketSideData *const src_sd = &pkt->side_data[i]; | |
| 1242 | 5779 | uint8_t *dst_data = av_packet_new_side_data(out_pkt, src_sd->type, src_sd->size); | |
| 1243 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5779 times.
|
5779 | if (!dst_data) { |
| 1244 | ✗ | ret = AVERROR(ENOMEM); | |
| 1245 | ✗ | goto fail; | |
| 1246 | } | ||
| 1247 | 5779 | memcpy(dst_data, src_sd->data, src_sd->size); | |
| 1248 | } | ||
| 1249 | } | ||
| 1250 | |||
| 1251 |
2/2✓ Branch 0 taken 651212 times.
✓ Branch 1 taken 238259 times.
|
889471 | if (!out_pkt->size) |
| 1252 | 651212 | continue; | |
| 1253 | |||
| 1254 |
4/4✓ Branch 0 taken 237000 times.
✓ Branch 1 taken 1259 times.
✓ Branch 2 taken 69135 times.
✓ Branch 3 taken 167865 times.
|
238259 | if (pkt->buf && out_pkt->data == pkt->data) { |
| 1255 | /* reference pkt->buf only when out_pkt->data is guaranteed to point | ||
| 1256 | * to data in it and not in the parser's internal buffer. */ | ||
| 1257 | /* XXX: Ensure this is the case with all parsers when sti->parser->flags | ||
| 1258 | * is PARSER_FLAG_COMPLETE_FRAMES and check for that instead? */ | ||
| 1259 | 69135 | out_pkt->buf = av_buffer_ref(pkt->buf); | |
| 1260 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 69135 times.
|
69135 | if (!out_pkt->buf) { |
| 1261 | ✗ | ret = AVERROR(ENOMEM); | |
| 1262 | ✗ | goto fail; | |
| 1263 | } | ||
| 1264 | } else { | ||
| 1265 | 169124 | ret = av_packet_make_refcounted(out_pkt); | |
| 1266 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 169124 times.
|
169124 | if (ret < 0) |
| 1267 | ✗ | goto fail; | |
| 1268 | } | ||
| 1269 | |||
| 1270 | /* set the duration */ | ||
| 1271 |
2/2✓ Branch 0 taken 50789 times.
✓ Branch 1 taken 187470 times.
|
238259 | out_pkt->duration = (sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0; |
| 1272 |
2/2✓ Branch 0 taken 156767 times.
✓ Branch 1 taken 81492 times.
|
238259 | if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { |
| 1273 |
6/6✓ Branch 0 taken 156657 times.
✓ Branch 1 taken 110 times.
✓ Branch 2 taken 156447 times.
✓ Branch 3 taken 210 times.
✓ Branch 4 taken 145267 times.
✓ Branch 5 taken 11180 times.
|
156767 | if (sti->avctx->sample_rate > 0 && !out_pkt->duration && sti->parser->duration > 0) { |
| 1274 | 145267 | out_pkt->duration = | |
| 1275 | 145267 | av_rescale_q_rnd(sti->parser->duration, | |
| 1276 | 145267 | (AVRational) { 1, sti->avctx->sample_rate }, | |
| 1277 | st->time_base, | ||
| 1278 | AV_ROUND_DOWN); | ||
| 1279 | } | ||
| 1280 |
2/2✓ Branch 0 taken 1822 times.
✓ Branch 1 taken 79670 times.
|
81492 | } else if (st->codecpar->codec_id == AV_CODEC_ID_GIF) { |
| 1281 |
2/4✓ Branch 0 taken 1822 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1822 times.
✗ Branch 3 not taken.
|
1822 | if (st->time_base.num > 0 && st->time_base.den > 0 && |
| 1282 |
1/2✓ Branch 0 taken 1822 times.
✗ Branch 1 not taken.
|
1822 | sti->parser->duration) { |
| 1283 | 1822 | out_pkt->duration = sti->parser->duration; | |
| 1284 | } | ||
| 1285 | } | ||
| 1286 | |||
| 1287 | 238259 | out_pkt->stream_index = st->index; | |
| 1288 | 238259 | out_pkt->pts = sti->parser->pts; | |
| 1289 | 238259 | out_pkt->dts = sti->parser->dts; | |
| 1290 | 238259 | out_pkt->pos = sti->parser->pos; | |
| 1291 | 238259 | out_pkt->flags |= pkt->flags & (AV_PKT_FLAG_DISCARD | AV_PKT_FLAG_CORRUPT); | |
| 1292 | |||
| 1293 |
2/2✓ Branch 0 taken 161974 times.
✓ Branch 1 taken 76285 times.
|
238259 | if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) |
| 1294 | 161974 | out_pkt->pos = sti->parser->frame_offset; | |
| 1295 | |||
| 1296 |
2/2✓ Branch 0 taken 227612 times.
✓ Branch 1 taken 10647 times.
|
238259 | if (sti->parser->key_frame == 1 || |
| 1297 |
2/2✓ Branch 0 taken 143876 times.
✓ Branch 1 taken 83736 times.
|
227612 | (sti->parser->key_frame == -1 && |
| 1298 |
2/2✓ Branch 0 taken 131552 times.
✓ Branch 1 taken 12324 times.
|
143876 | sti->parser->pict_type == AV_PICTURE_TYPE_I)) |
| 1299 | 142199 | out_pkt->flags |= AV_PKT_FLAG_KEY; | |
| 1300 | |||
| 1301 |
6/6✓ Branch 0 taken 143876 times.
✓ Branch 1 taken 94383 times.
✓ Branch 2 taken 322 times.
✓ Branch 3 taken 143554 times.
✓ Branch 4 taken 291 times.
✓ Branch 5 taken 31 times.
|
238259 | if (sti->parser->key_frame == -1 && sti->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY)) |
| 1302 | 291 | out_pkt->flags |= AV_PKT_FLAG_KEY; | |
| 1303 | |||
| 1304 | 238259 | compute_pkt_fields(s, st, sti->parser, out_pkt, next_dts, next_pts); | |
| 1305 | |||
| 1306 | 238259 | ret = ff_packet_list_put(&fci->parse_queue, | |
| 1307 | out_pkt, NULL, 0); | ||
| 1308 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 238259 times.
|
238259 | if (ret < 0) |
| 1309 | ✗ | goto fail; | |
| 1310 | } | ||
| 1311 | |||
| 1312 | /* end of the stream => close and free the parser */ | ||
| 1313 |
2/2✓ Branch 0 taken 718147 times.
✓ Branch 1 taken 2273 times.
|
720420 | if (flush) { |
| 1314 | 2273 | av_parser_close(sti->parser); | |
| 1315 | 2273 | sti->parser = NULL; | |
| 1316 | } | ||
| 1317 | |||
| 1318 | 718147 | fail: | |
| 1319 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 720414 times.
|
720420 | if (sd) { |
| 1320 | 6 | sti->avctx->extradata = extradata; | |
| 1321 | 6 | sti->avctx->extradata_size = extradata_size; | |
| 1322 | } | ||
| 1323 |
2/2✓ Branch 0 taken 10782 times.
✓ Branch 1 taken 709638 times.
|
720420 | if (pkt_side_data_consumed) { |
| 1324 | 10782 | pkt->side_data = NULL; | |
| 1325 | 10782 | pkt->side_data_elems = 0; | |
| 1326 | } | ||
| 1327 | |||
| 1328 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 720420 times.
|
720420 | if (ret < 0) |
| 1329 | ✗ | av_packet_unref(out_pkt); | |
| 1330 | 720420 | av_packet_unref(pkt); | |
| 1331 | 720420 | return ret; | |
| 1332 | } | ||
| 1333 | |||
| 1334 | 49103 | static int64_t ts_to_samples(AVStream *st, int64_t ts) | |
| 1335 | { | ||
| 1336 | 49103 | return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den); | |
| 1337 | } | ||
| 1338 | |||
| 1339 | 8928 | static int codec_close(FFStream *sti) | |
| 1340 | { | ||
| 1341 | 8928 | AVCodecContext *avctx_new = NULL; | |
| 1342 | 8928 | AVCodecParameters *par_tmp = NULL; | |
| 1343 | 8928 | const AVCodec *new_codec = NULL; | |
| 1344 | int ret; | ||
| 1345 | |||
| 1346 | 8928 | new_codec = | |
| 1347 | 8928 | (sti->avctx->codec_id != sti->pub.codecpar->codec_id) ? | |
| 1348 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 8917 times.
|
8928 | avcodec_find_decoder(sti->pub.codecpar->codec_id) : |
| 1349 | 8917 | sti->avctx->codec; | |
| 1350 | |||
| 1351 | 8928 | avctx_new = avcodec_alloc_context3(new_codec); | |
| 1352 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8928 times.
|
8928 | if (!avctx_new) { |
| 1353 | ✗ | ret = AVERROR(ENOMEM); | |
| 1354 | ✗ | goto fail; | |
| 1355 | } | ||
| 1356 | |||
| 1357 | 8928 | par_tmp = avcodec_parameters_alloc(); | |
| 1358 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8928 times.
|
8928 | if (!par_tmp) { |
| 1359 | ✗ | ret = AVERROR(ENOMEM); | |
| 1360 | ✗ | goto fail; | |
| 1361 | } | ||
| 1362 | |||
| 1363 | 8928 | ret = avcodec_parameters_from_context(par_tmp, sti->avctx); | |
| 1364 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8928 times.
|
8928 | if (ret < 0) |
| 1365 | ✗ | goto fail; | |
| 1366 | |||
| 1367 | 8928 | ret = avcodec_parameters_to_context(avctx_new, par_tmp); | |
| 1368 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8928 times.
|
8928 | if (ret < 0) |
| 1369 | ✗ | goto fail; | |
| 1370 | |||
| 1371 | 8928 | avctx_new->pkt_timebase = sti->avctx->pkt_timebase; | |
| 1372 | |||
| 1373 | 8928 | avcodec_free_context(&sti->avctx); | |
| 1374 | 8928 | sti->avctx = avctx_new; | |
| 1375 | |||
| 1376 | 8928 | avctx_new = NULL; | |
| 1377 | 8928 | ret = 0; | |
| 1378 | |||
| 1379 | 8928 | fail: | |
| 1380 | 8928 | avcodec_free_context(&avctx_new); | |
| 1381 | 8928 | avcodec_parameters_free(&par_tmp); | |
| 1382 | |||
| 1383 | 8928 | return ret; | |
| 1384 | } | ||
| 1385 | |||
| 1386 | static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt); | ||
| 1387 | |||
| 1388 | 647447 | static int read_frame_internal(AVFormatContext *s, AVPacket *pkt) | |
| 1389 | { | ||
| 1390 | 647447 | FormatContextInternal *const fci = ff_fc_internal(s); | |
| 1391 | 647447 | FFFormatContext *const si = &fci->fc; | |
| 1392 | 647447 | int ret, got_packet = 0; | |
| 1393 | 647447 | AVDictionary *metadata = NULL; | |
| 1394 | |||
| 1395 |
4/4✓ Branch 0 taken 1365727 times.
✓ Branch 1 taken 404098 times.
✓ Branch 2 taken 1129407 times.
✓ Branch 3 taken 236320 times.
|
1769825 | while (!got_packet && !fci->parse_queue.head) { |
| 1396 | AVStream *st; | ||
| 1397 | FFStream *sti; | ||
| 1398 | |||
| 1399 | /* read next packet */ | ||
| 1400 | 1129407 | ret = ff_read_packet(s, pkt); | |
| 1401 |
2/2✓ Branch 0 taken 7029 times.
✓ Branch 1 taken 1122378 times.
|
1129407 | if (ret < 0) { |
| 1402 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 7028 times.
|
7029 | if (ret == AVERROR(EAGAIN)) |
| 1403 | 1 | return ret; | |
| 1404 | /* flush the parsers */ | ||
| 1405 |
2/2✓ Branch 0 taken 8184 times.
✓ Branch 1 taken 7028 times.
|
15212 | for (unsigned i = 0; i < s->nb_streams; i++) { |
| 1406 | 8184 | AVStream *const st = s->streams[i]; | |
| 1407 | 8184 | FFStream *const sti = ffstream(st); | |
| 1408 |
4/4✓ Branch 0 taken 3125 times.
✓ Branch 1 taken 5059 times.
✓ Branch 2 taken 2273 times.
✓ Branch 3 taken 852 times.
|
8184 | if (sti->parser && sti->need_parsing) |
| 1409 | 2273 | parse_packet(s, pkt, st->index, 1); | |
| 1410 | } | ||
| 1411 | /* all remaining packets are now in parse_queue => | ||
| 1412 | * really terminate parsing */ | ||
| 1413 | 7028 | break; | |
| 1414 | } | ||
| 1415 | 1122378 | ret = 0; | |
| 1416 | 1122378 | st = s->streams[pkt->stream_index]; | |
| 1417 | 1122378 | sti = ffstream(st); | |
| 1418 | |||
| 1419 | 1122378 | st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS; | |
| 1420 | |||
| 1421 | 1122378 | int new_extradata = !!av_packet_side_data_get(pkt->side_data, pkt->side_data_elems, | |
| 1422 | AV_PKT_DATA_NEW_EXTRADATA); | ||
| 1423 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 1122358 times.
|
1122378 | if (new_extradata) |
| 1424 | 20 | sti->need_context_update = 1; | |
| 1425 | |||
| 1426 | /* update context if required */ | ||
| 1427 |
2/2✓ Branch 0 taken 184 times.
✓ Branch 1 taken 1122194 times.
|
1122378 | if (sti->need_context_update) { |
| 1428 |
2/2✓ Branch 1 taken 15 times.
✓ Branch 2 taken 169 times.
|
184 | if (avcodec_is_open(sti->avctx)) { |
| 1429 | 15 | av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n"); | |
| 1430 | 15 | ret = codec_close(sti); | |
| 1431 | 15 | sti->info->found_decoder = 0; | |
| 1432 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | if (ret < 0) |
| 1433 | ✗ | return ret; | |
| 1434 | } | ||
| 1435 | |||
| 1436 | /* close parser, because it depends on the codec and extradata */ | ||
| 1437 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 157 times.
|
184 | if (sti->parser && |
| 1438 |
4/4✓ Branch 0 taken 16 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 13 times.
✓ Branch 3 taken 3 times.
|
27 | (sti->avctx->codec_id != st->codecpar->codec_id || new_extradata)) { |
| 1439 | 24 | av_parser_close(sti->parser); | |
| 1440 | 24 | sti->parser = NULL; | |
| 1441 | } | ||
| 1442 | |||
| 1443 | 184 | ret = avcodec_parameters_to_context(sti->avctx, st->codecpar); | |
| 1444 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 184 times.
|
184 | if (ret < 0) { |
| 1445 | ✗ | av_packet_unref(pkt); | |
| 1446 | ✗ | return ret; | |
| 1447 | } | ||
| 1448 | |||
| 1449 |
2/2✓ Branch 0 taken 141 times.
✓ Branch 1 taken 43 times.
|
184 | if (!sti->avctx->extradata) { |
| 1450 | 141 | sti->extract_extradata.inited = 0; | |
| 1451 | |||
| 1452 | 141 | ret = extract_extradata(si, st, pkt); | |
| 1453 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 141 times.
|
141 | if (ret < 0) { |
| 1454 | ✗ | av_packet_unref(pkt); | |
| 1455 | ✗ | return ret; | |
| 1456 | } | ||
| 1457 | } | ||
| 1458 | |||
| 1459 | 184 | sti->codec_desc = avcodec_descriptor_get(sti->avctx->codec_id); | |
| 1460 | |||
| 1461 | 184 | sti->need_context_update = 0; | |
| 1462 | } | ||
| 1463 | |||
| 1464 |
2/2✓ Branch 0 taken 348861 times.
✓ Branch 1 taken 773517 times.
|
1122378 | if (pkt->pts != AV_NOPTS_VALUE && |
| 1465 |
2/2✓ Branch 0 taken 172643 times.
✓ Branch 1 taken 176218 times.
|
348861 | pkt->dts != AV_NOPTS_VALUE && |
| 1466 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 172643 times.
|
172643 | pkt->pts < pkt->dts) { |
| 1467 | ✗ | av_log(s, AV_LOG_WARNING, | |
| 1468 | "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n", | ||
| 1469 | pkt->stream_index, | ||
| 1470 | ✗ | av_ts2str(pkt->pts), | |
| 1471 | ✗ | av_ts2str(pkt->dts), | |
| 1472 | pkt->size); | ||
| 1473 | } | ||
| 1474 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1122378 times.
|
1122378 | if (s->debug & AV_FDEBUG_TS) |
| 1475 | ✗ | av_log(s, AV_LOG_DEBUG, | |
| 1476 | "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n", | ||
| 1477 | pkt->stream_index, | ||
| 1478 | ✗ | av_ts2str(pkt->pts), | |
| 1479 | ✗ | av_ts2str(pkt->dts), | |
| 1480 | pkt->size, pkt->duration, pkt->flags); | ||
| 1481 | |||
| 1482 |
5/6✓ Branch 0 taken 719526 times.
✓ Branch 1 taken 402852 times.
✓ Branch 2 taken 2939 times.
✓ Branch 3 taken 716587 times.
✓ Branch 4 taken 2939 times.
✗ Branch 5 not taken.
|
1122378 | if (sti->need_parsing && !sti->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) { |
| 1483 | 2939 | sti->parser = av_parser_init(st->codecpar->codec_id); | |
| 1484 |
2/2✓ Branch 0 taken 1246 times.
✓ Branch 1 taken 1693 times.
|
2939 | if (!sti->parser) { |
| 1485 | 1246 | av_log(s, AV_LOG_VERBOSE, "parser not found for codec " | |
| 1486 | "%s, packets or times may be invalid.\n", | ||
| 1487 | 1246 | avcodec_get_name(st->codecpar->codec_id)); | |
| 1488 | /* no parser available: just output the raw packets */ | ||
| 1489 | 1246 | sti->need_parsing = AVSTREAM_PARSE_NONE; | |
| 1490 |
2/2✓ Branch 0 taken 725 times.
✓ Branch 1 taken 968 times.
|
1693 | } else if (sti->need_parsing == AVSTREAM_PARSE_HEADERS) |
| 1491 | 725 | sti->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES; | |
| 1492 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 968 times.
|
968 | else if (sti->need_parsing == AVSTREAM_PARSE_FULL_ONCE) |
| 1493 | ✗ | sti->parser->flags |= PARSER_FLAG_ONCE; | |
| 1494 |
2/2✓ Branch 0 taken 478 times.
✓ Branch 1 taken 490 times.
|
968 | else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) |
| 1495 | 478 | sti->parser->flags |= PARSER_FLAG_USE_CODEC_TS; | |
| 1496 | } | ||
| 1497 | |||
| 1498 |
3/4✓ Branch 0 taken 718280 times.
✓ Branch 1 taken 404098 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 718280 times.
|
1122378 | if (!sti->need_parsing || !sti->parser) { |
| 1499 | /* no parsing needed: we just output the packet as is */ | ||
| 1500 | 404098 | compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE); | |
| 1501 |
2/2✓ Branch 0 taken 96335 times.
✓ Branch 1 taken 307763 times.
|
404098 | if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && |
| 1502 |
4/4✓ Branch 0 taken 95465 times.
✓ Branch 1 taken 870 times.
✓ Branch 2 taken 95192 times.
✓ Branch 3 taken 273 times.
|
96335 | (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) { |
| 1503 | 95192 | ff_reduce_index(s, st->index); | |
| 1504 | 95192 | av_add_index_entry(st, pkt->pos, pkt->dts, | |
| 1505 | 0, 0, AVINDEX_KEYFRAME); | ||
| 1506 | } | ||
| 1507 | 404098 | got_packet = 1; | |
| 1508 |
2/2✓ Branch 0 taken 718147 times.
✓ Branch 1 taken 133 times.
|
718280 | } else if (st->discard < AVDISCARD_ALL) { |
| 1509 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 718147 times.
|
718147 | if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0) |
| 1510 | ✗ | return ret; | |
| 1511 | 718147 | st->codecpar->sample_rate = sti->avctx->sample_rate; | |
| 1512 | 718147 | st->codecpar->bit_rate = sti->avctx->bit_rate; | |
| 1513 | 718147 | ret = av_channel_layout_copy(&st->codecpar->ch_layout, &sti->avctx->ch_layout); | |
| 1514 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 718147 times.
|
718147 | if (ret < 0) |
| 1515 | ✗ | return ret; | |
| 1516 | 718147 | st->codecpar->codec_id = sti->avctx->codec_id; | |
| 1517 | } else { | ||
| 1518 | /* free packet */ | ||
| 1519 | 133 | av_packet_unref(pkt); | |
| 1520 | } | ||
| 1521 |
2/2✓ Branch 0 taken 377856 times.
✓ Branch 1 taken 744522 times.
|
1122378 | if (pkt->flags & AV_PKT_FLAG_KEY) |
| 1522 | 377856 | sti->skip_to_keyframe = 0; | |
| 1523 |
2/2✓ Branch 0 taken 85 times.
✓ Branch 1 taken 1122293 times.
|
1122378 | if (sti->skip_to_keyframe) { |
| 1524 | 85 | av_packet_unref(pkt); | |
| 1525 | 85 | got_packet = 0; | |
| 1526 | } | ||
| 1527 | } | ||
| 1528 | |||
| 1529 |
4/4✓ Branch 0 taken 243348 times.
✓ Branch 1 taken 404098 times.
✓ Branch 2 taken 237314 times.
✓ Branch 3 taken 6034 times.
|
647446 | if (!got_packet && fci->parse_queue.head) |
| 1530 | 237314 | ret = ff_packet_list_get(&fci->parse_queue, pkt); | |
| 1531 | |||
| 1532 |
2/2✓ Branch 0 taken 641412 times.
✓ Branch 1 taken 6034 times.
|
647446 | if (ret >= 0) { |
| 1533 | 641412 | AVStream *const st = s->streams[pkt->stream_index]; | |
| 1534 | 641412 | FFStream *const sti = ffstream(st); | |
| 1535 | 641412 | int discard_padding = 0; | |
| 1536 |
3/4✓ Branch 0 taken 16373 times.
✓ Branch 1 taken 625039 times.
✓ Branch 2 taken 16373 times.
✗ Branch 3 not taken.
|
641412 | if (sti->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) { |
| 1537 |
2/2✓ Branch 1 taken 6911 times.
✓ Branch 2 taken 9462 times.
|
16373 | int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0); |
| 1538 | 16373 | int64_t sample = ts_to_samples(st, pts); | |
| 1539 |
2/2✓ Branch 1 taken 16 times.
✓ Branch 2 taken 16357 times.
|
16373 | int64_t duration = FFMAX(st->codecpar->frame_size, ts_to_samples(st, pkt->duration)); |
| 1540 | 16373 | int64_t end_sample = sample + duration; | |
| 1541 |
3/4✓ Branch 0 taken 16373 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 325 times.
✓ Branch 3 taken 16048 times.
|
16373 | if (duration > 0 && end_sample >= sti->first_discard_sample && |
| 1542 |
2/2✓ Branch 0 taken 321 times.
✓ Branch 1 taken 4 times.
|
325 | sample < sti->last_discard_sample) |
| 1543 | 321 | discard_padding = FFMIN(end_sample - sti->first_discard_sample, duration); | |
| 1544 | } | ||
| 1545 |
6/6✓ Branch 0 taken 9577 times.
✓ Branch 1 taken 631835 times.
✓ Branch 2 taken 9559 times.
✓ Branch 3 taken 18 times.
✓ Branch 4 taken 125 times.
✓ Branch 5 taken 9434 times.
|
641412 | if (sti->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE)) |
| 1546 | 143 | sti->skip_samples = sti->start_skip_samples; | |
| 1547 | 641412 | sti->skip_samples = FFMAX(0, sti->skip_samples); | |
| 1548 |
4/4✓ Branch 0 taken 641172 times.
✓ Branch 1 taken 240 times.
✓ Branch 2 taken 125 times.
✓ Branch 3 taken 641047 times.
|
641412 | if (sti->skip_samples || discard_padding) { |
| 1549 | 365 | uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10); | |
| 1550 |
1/2✓ Branch 0 taken 365 times.
✗ Branch 1 not taken.
|
365 | if (p) { |
| 1551 | 365 | AV_WL32(p, sti->skip_samples); | |
| 1552 | 365 | AV_WL32(p + 4, discard_padding); | |
| 1553 | 365 | av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %u / discard %u\n", | |
| 1554 | 365 | (unsigned)sti->skip_samples, (unsigned)discard_padding); | |
| 1555 | } | ||
| 1556 | 365 | sti->skip_samples = 0; | |
| 1557 | } | ||
| 1558 | } | ||
| 1559 | |||
| 1560 |
2/2✓ Branch 0 taken 8133 times.
✓ Branch 1 taken 639313 times.
|
647446 | if (!fci->metafree) { |
| 1561 | 8133 | int metaret = av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata); | |
| 1562 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8133 times.
|
8133 | if (metadata) { |
| 1563 | ✗ | s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED; | |
| 1564 | ✗ | av_dict_copy(&s->metadata, metadata, 0); | |
| 1565 | ✗ | av_dict_free(&metadata); | |
| 1566 | ✗ | av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN); | |
| 1567 | } | ||
| 1568 | 8133 | fci->metafree = metaret == AVERROR_OPTION_NOT_FOUND; | |
| 1569 | } | ||
| 1570 | |||
| 1571 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 647446 times.
|
647446 | if (s->debug & AV_FDEBUG_TS) |
| 1572 | ✗ | av_log(s, AV_LOG_DEBUG, | |
| 1573 | "read_frame_internal stream=%d, pts=%s, dts=%s, " | ||
| 1574 | "size=%d, duration=%"PRId64", flags=%d\n", | ||
| 1575 | pkt->stream_index, | ||
| 1576 | ✗ | av_ts2str(pkt->pts), | |
| 1577 | ✗ | av_ts2str(pkt->dts), | |
| 1578 | pkt->size, pkt->duration, pkt->flags); | ||
| 1579 | |||
| 1580 | /* A demuxer might have returned EOF because of an IO error, let's | ||
| 1581 | * propagate this back to the user. */ | ||
| 1582 |
5/8✓ Branch 0 taken 5925 times.
✓ Branch 1 taken 641521 times.
✓ Branch 2 taken 5679 times.
✓ Branch 3 taken 246 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5679 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
647446 | if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN)) |
| 1583 | ✗ | ret = s->pb->error; | |
| 1584 | |||
| 1585 | 647446 | return ret; | |
| 1586 | } | ||
| 1587 | |||
| 1588 | 565327 | int av_read_frame(AVFormatContext *s, AVPacket *pkt) | |
| 1589 | { | ||
| 1590 | 565327 | FFFormatContext *const si = ffformatcontext(s); | |
| 1591 | 565327 | const int genpts = s->flags & AVFMT_FLAG_GENPTS; | |
| 1592 | 565327 | int eof = 0; | |
| 1593 | int ret; | ||
| 1594 | AVStream *st; | ||
| 1595 | |||
| 1596 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 565327 times.
|
565327 | if (!genpts) { |
| 1597 | 1130654 | ret = si->packet_buffer.head | |
| 1598 | 120172 | ? ff_packet_list_get(&si->packet_buffer, pkt) | |
| 1599 |
2/2✓ Branch 0 taken 120172 times.
✓ Branch 1 taken 445155 times.
|
565327 | : read_frame_internal(s, pkt); |
| 1600 |
2/2✓ Branch 0 taken 4673 times.
✓ Branch 1 taken 560654 times.
|
565327 | if (ret < 0) |
| 1601 | 4673 | return ret; | |
| 1602 | 560654 | goto return_packet; | |
| 1603 | } | ||
| 1604 | |||
| 1605 | ✗ | for (;;) { | |
| 1606 | ✗ | PacketListEntry *pktl = si->packet_buffer.head; | |
| 1607 | |||
| 1608 | ✗ | if (pktl) { | |
| 1609 | ✗ | AVPacket *next_pkt = &pktl->pkt; | |
| 1610 | |||
| 1611 | ✗ | if (next_pkt->dts != AV_NOPTS_VALUE) { | |
| 1612 | ✗ | int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits; | |
| 1613 | // last dts seen for this stream. if any of packets following | ||
| 1614 | // current one had no dts, we will set this to AV_NOPTS_VALUE. | ||
| 1615 | ✗ | int64_t last_dts = next_pkt->dts; | |
| 1616 | av_assert2(wrap_bits <= 64); | ||
| 1617 | ✗ | while (pktl && next_pkt->pts == AV_NOPTS_VALUE) { | |
| 1618 | ✗ | if (pktl->pkt.stream_index == next_pkt->stream_index && | |
| 1619 | ✗ | av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2ULL << (wrap_bits - 1)) < 0) { | |
| 1620 | ✗ | if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2ULL << (wrap_bits - 1))) { | |
| 1621 | // not B-frame | ||
| 1622 | ✗ | next_pkt->pts = pktl->pkt.dts; | |
| 1623 | } | ||
| 1624 | ✗ | if (last_dts != AV_NOPTS_VALUE) { | |
| 1625 | // Once last dts was set to AV_NOPTS_VALUE, we don't change it. | ||
| 1626 | ✗ | last_dts = pktl->pkt.dts; | |
| 1627 | } | ||
| 1628 | } | ||
| 1629 | ✗ | pktl = pktl->next; | |
| 1630 | } | ||
| 1631 | ✗ | if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) { | |
| 1632 | // Fixing the last reference frame had none pts issue (For MXF etc). | ||
| 1633 | // We only do this when | ||
| 1634 | // 1. eof. | ||
| 1635 | // 2. we are not able to resolve a pts value for current packet. | ||
| 1636 | // 3. the packets for this stream at the end of the files had valid dts. | ||
| 1637 | ✗ | next_pkt->pts = last_dts + next_pkt->duration; | |
| 1638 | } | ||
| 1639 | ✗ | pktl = si->packet_buffer.head; | |
| 1640 | } | ||
| 1641 | |||
| 1642 | /* read packet from packet buffer, if there is data */ | ||
| 1643 | ✗ | st = s->streams[next_pkt->stream_index]; | |
| 1644 | ✗ | if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL && | |
| 1645 | ✗ | next_pkt->dts != AV_NOPTS_VALUE && !eof)) { | |
| 1646 | ✗ | ret = ff_packet_list_get(&si->packet_buffer, pkt); | |
| 1647 | ✗ | goto return_packet; | |
| 1648 | } | ||
| 1649 | } | ||
| 1650 | |||
| 1651 | ✗ | ret = read_frame_internal(s, pkt); | |
| 1652 | ✗ | if (ret < 0) { | |
| 1653 | ✗ | if (pktl && ret != AVERROR(EAGAIN)) { | |
| 1654 | ✗ | eof = 1; | |
| 1655 | ✗ | continue; | |
| 1656 | } else | ||
| 1657 | ✗ | return ret; | |
| 1658 | } | ||
| 1659 | |||
| 1660 | ✗ | ret = ff_packet_list_put(&si->packet_buffer, | |
| 1661 | pkt, NULL, 0); | ||
| 1662 | ✗ | if (ret < 0) { | |
| 1663 | ✗ | av_packet_unref(pkt); | |
| 1664 | ✗ | return ret; | |
| 1665 | } | ||
| 1666 | } | ||
| 1667 | |||
| 1668 | 560654 | return_packet: | |
| 1669 | 560654 | st = s->streams[pkt->stream_index]; | |
| 1670 |
4/4✓ Branch 0 taken 242832 times.
✓ Branch 1 taken 317822 times.
✓ Branch 2 taken 168061 times.
✓ Branch 3 taken 74771 times.
|
560654 | if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) { |
| 1671 | 168061 | ff_reduce_index(s, st->index); | |
| 1672 | 168061 | av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME); | |
| 1673 | } | ||
| 1674 | |||
| 1675 |
2/2✓ Branch 1 taken 158467 times.
✓ Branch 2 taken 402187 times.
|
560654 | if (is_relative(pkt->dts)) |
| 1676 | 158467 | pkt->dts -= RELATIVE_TS_BASE; | |
| 1677 |
2/2✓ Branch 1 taken 156774 times.
✓ Branch 2 taken 403880 times.
|
560654 | if (is_relative(pkt->pts)) |
| 1678 | 156774 | pkt->pts -= RELATIVE_TS_BASE; | |
| 1679 | |||
| 1680 | 560654 | return ret; | |
| 1681 | } | ||
| 1682 | |||
| 1683 | /** | ||
| 1684 | * Return TRUE if the stream has accurate duration in any stream. | ||
| 1685 | * | ||
| 1686 | * @return TRUE if the stream has accurate duration for at least one component. | ||
| 1687 | */ | ||
| 1688 | 8045 | static int has_duration(AVFormatContext *ic) | |
| 1689 | { | ||
| 1690 |
2/2✓ Branch 0 taken 8392 times.
✓ Branch 1 taken 2630 times.
|
11022 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1691 | 8392 | const AVStream *const st = ic->streams[i]; | |
| 1692 |
2/2✓ Branch 0 taken 5415 times.
✓ Branch 1 taken 2977 times.
|
8392 | if (st->duration != AV_NOPTS_VALUE) |
| 1693 | 5415 | return 1; | |
| 1694 | } | ||
| 1695 |
2/2✓ Branch 0 taken 507 times.
✓ Branch 1 taken 2123 times.
|
2630 | if (ic->duration != AV_NOPTS_VALUE) |
| 1696 | 507 | return 1; | |
| 1697 | 2123 | return 0; | |
| 1698 | } | ||
| 1699 | |||
| 1700 | /** | ||
| 1701 | * Estimate the stream timings from the one of each components. | ||
| 1702 | * | ||
| 1703 | * Also computes the global bitrate if possible. | ||
| 1704 | */ | ||
| 1705 | 14149 | static void update_stream_timings(AVFormatContext *ic) | |
| 1706 | { | ||
| 1707 | int64_t start_time, start_time1, start_time_text, end_time, end_time1, end_time_text; | ||
| 1708 | int64_t duration, duration1, duration_text, filesize; | ||
| 1709 | |||
| 1710 | 14149 | start_time = INT64_MAX; | |
| 1711 | 14149 | start_time_text = INT64_MAX; | |
| 1712 | 14149 | end_time = INT64_MIN; | |
| 1713 | 14149 | end_time_text = INT64_MIN; | |
| 1714 | 14149 | duration = INT64_MIN; | |
| 1715 | 14149 | duration_text = INT64_MIN; | |
| 1716 | |||
| 1717 |
2/2✓ Branch 0 taken 15768 times.
✓ Branch 1 taken 14149 times.
|
29917 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1718 | 15768 | AVStream *const st = ic->streams[i]; | |
| 1719 |
2/2✓ Branch 0 taken 15627 times.
✓ Branch 1 taken 141 times.
|
31395 | int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE || |
| 1720 |
2/2✓ Branch 0 taken 159 times.
✓ Branch 1 taken 15468 times.
|
15627 | st->codecpar->codec_type == AVMEDIA_TYPE_DATA; |
| 1721 | |||
| 1722 |
3/4✓ Branch 0 taken 12888 times.
✓ Branch 1 taken 2880 times.
✓ Branch 2 taken 12888 times.
✗ Branch 3 not taken.
|
15768 | if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) { |
| 1723 | 12888 | start_time1 = av_rescale_q(st->start_time, st->time_base, | |
| 1724 | 12888 | AV_TIME_BASE_Q); | |
| 1725 |
2/2✓ Branch 0 taken 166 times.
✓ Branch 1 taken 12722 times.
|
12888 | if (is_text) |
| 1726 | 166 | start_time_text = FFMIN(start_time_text, start_time1); | |
| 1727 | else | ||
| 1728 | 12722 | start_time = FFMIN(start_time, start_time1); | |
| 1729 | 12888 | end_time1 = av_rescale_q_rnd(st->duration, st->time_base, | |
| 1730 | 12888 | AV_TIME_BASE_Q, | |
| 1731 | AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX); | ||
| 1732 |
5/6✓ Branch 0 taken 11340 times.
✓ Branch 1 taken 1548 times.
✓ Branch 2 taken 11311 times.
✓ Branch 3 taken 29 times.
✓ Branch 4 taken 11340 times.
✗ Branch 5 not taken.
|
12888 | if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) { |
| 1733 | 11340 | end_time1 += start_time1; | |
| 1734 |
2/2✓ Branch 0 taken 149 times.
✓ Branch 1 taken 11191 times.
|
11340 | if (is_text) |
| 1735 | 149 | end_time_text = FFMAX(end_time_text, end_time1); | |
| 1736 | else | ||
| 1737 | 11191 | end_time = FFMAX(end_time, end_time1); | |
| 1738 | } | ||
| 1739 |
2/2✓ Branch 1 taken 273 times.
✓ Branch 2 taken 12888 times.
|
13161 | for (AVProgram *p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) { |
| 1740 |
4/4✓ Branch 0 taken 191 times.
✓ Branch 1 taken 82 times.
✓ Branch 2 taken 25 times.
✓ Branch 3 taken 166 times.
|
273 | if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1) |
| 1741 | 107 | p->start_time = start_time1; | |
| 1742 |
2/2✓ Branch 0 taken 73 times.
✓ Branch 1 taken 200 times.
|
273 | if (p->end_time < end_time1) |
| 1743 | 73 | p->end_time = end_time1; | |
| 1744 | } | ||
| 1745 | } | ||
| 1746 |
2/2✓ Branch 0 taken 12901 times.
✓ Branch 1 taken 2867 times.
|
15768 | if (st->duration != AV_NOPTS_VALUE) { |
| 1747 | 12901 | duration1 = av_rescale_q(st->duration, st->time_base, | |
| 1748 | 12901 | AV_TIME_BASE_Q); | |
| 1749 |
2/2✓ Branch 0 taken 179 times.
✓ Branch 1 taken 12722 times.
|
12901 | if (is_text) |
| 1750 | 179 | duration_text = FFMAX(duration_text, duration1); | |
| 1751 | else | ||
| 1752 | 12722 | duration = FFMAX(duration, duration1); | |
| 1753 | } | ||
| 1754 | } | ||
| 1755 |
3/6✓ Branch 0 taken 11530 times.
✓ Branch 1 taken 2619 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11530 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
14149 | if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE)) |
| 1756 | 2619 | start_time = start_time_text; | |
| 1757 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11530 times.
|
11530 | else if (start_time > start_time_text) |
| 1758 | ✗ | av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE); | |
| 1759 | |||
| 1760 |
6/6✓ Branch 0 taken 10437 times.
✓ Branch 1 taken 3712 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 10431 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 2 times.
|
14149 | if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE)) |
| 1761 | 3716 | end_time = end_time_text; | |
| 1762 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 10431 times.
|
10433 | else if (end_time < end_time_text) |
| 1763 | 2 | av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream endtime %f\n", end_time_text / (float)AV_TIME_BASE); | |
| 1764 | |||
| 1765 |
6/6✓ Branch 0 taken 11950 times.
✓ Branch 1 taken 2199 times.
✓ Branch 2 taken 12 times.
✓ Branch 3 taken 11938 times.
✓ Branch 4 taken 10 times.
✓ Branch 5 taken 2 times.
|
14149 | if (duration == INT64_MIN || (duration < duration_text && (uint64_t)duration_text - duration < AV_TIME_BASE)) |
| 1766 | 2209 | duration = duration_text; | |
| 1767 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 11938 times.
|
11940 | else if (duration < duration_text) |
| 1768 | 2 | av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream duration %f\n", duration_text / (float)AV_TIME_BASE); | |
| 1769 | |||
| 1770 |
2/2✓ Branch 0 taken 11553 times.
✓ Branch 1 taken 2596 times.
|
14149 | if (start_time != INT64_MAX) { |
| 1771 | 11553 | ic->start_time = start_time; | |
| 1772 |
2/2✓ Branch 0 taken 10454 times.
✓ Branch 1 taken 1099 times.
|
11553 | if (end_time != INT64_MIN) { |
| 1773 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10454 times.
|
10454 | if (ic->nb_programs > 1) { |
| 1774 | ✗ | for (unsigned i = 0; i < ic->nb_programs; i++) { | |
| 1775 | ✗ | AVProgram *const p = ic->programs[i]; | |
| 1776 | |||
| 1777 | ✗ | if (p->start_time != AV_NOPTS_VALUE && | |
| 1778 | ✗ | p->end_time > p->start_time && | |
| 1779 | ✗ | p->end_time - (uint64_t)p->start_time <= INT64_MAX) | |
| 1780 | ✗ | duration = FFMAX(duration, p->end_time - p->start_time); | |
| 1781 | } | ||
| 1782 |
2/4✓ Branch 0 taken 10454 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10454 times.
✗ Branch 3 not taken.
|
10454 | } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) { |
| 1783 | 10454 | duration = FFMAX(duration, end_time - start_time); | |
| 1784 | } | ||
| 1785 | } | ||
| 1786 | } | ||
| 1787 |
6/6✓ Branch 0 taken 11980 times.
✓ Branch 1 taken 2169 times.
✓ Branch 2 taken 11944 times.
✓ Branch 3 taken 36 times.
✓ Branch 4 taken 6384 times.
✓ Branch 5 taken 5560 times.
|
14149 | if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) { |
| 1788 | 6384 | ic->duration = duration; | |
| 1789 | } | ||
| 1790 |
6/6✓ Branch 0 taken 7831 times.
✓ Branch 1 taken 6318 times.
✓ Branch 3 taken 7830 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 6644 times.
✓ Branch 6 taken 1186 times.
|
14149 | if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) { |
| 1791 | /* compute the bitrate */ | ||
| 1792 | 6644 | double bitrate = (double) filesize * 8.0 * AV_TIME_BASE / | |
| 1793 | 6644 | (double) ic->duration; | |
| 1794 |
2/4✓ Branch 0 taken 6644 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6644 times.
✗ Branch 3 not taken.
|
6644 | if (bitrate >= 0 && bitrate <= INT64_MAX) |
| 1795 | 6644 | ic->bit_rate = bitrate; | |
| 1796 | } | ||
| 1797 | 14149 | } | |
| 1798 | |||
| 1799 | 6013 | static void fill_all_stream_timings(AVFormatContext *ic) | |
| 1800 | { | ||
| 1801 | 6013 | update_stream_timings(ic); | |
| 1802 |
2/2✓ Branch 0 taken 6730 times.
✓ Branch 1 taken 6013 times.
|
12743 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1803 | 6730 | AVStream *const st = ic->streams[i]; | |
| 1804 | |||
| 1805 |
2/2✓ Branch 0 taken 856 times.
✓ Branch 1 taken 5874 times.
|
6730 | if (st->start_time == AV_NOPTS_VALUE) { |
| 1806 |
2/2✓ Branch 0 taken 153 times.
✓ Branch 1 taken 703 times.
|
856 | if (ic->start_time != AV_NOPTS_VALUE) |
| 1807 | 153 | st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, | |
| 1808 | st->time_base); | ||
| 1809 |
2/2✓ Branch 0 taken 841 times.
✓ Branch 1 taken 15 times.
|
856 | if (ic->duration != AV_NOPTS_VALUE) |
| 1810 | 841 | st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, | |
| 1811 | st->time_base); | ||
| 1812 | } | ||
| 1813 | } | ||
| 1814 | 6013 | } | |
| 1815 | |||
| 1816 | 2123 | static void estimate_timings_from_bit_rate(AVFormatContext *ic) | |
| 1817 | { | ||
| 1818 | 2123 | FFFormatContext *const si = ffformatcontext(ic); | |
| 1819 | 2123 | int show_warning = 0; | |
| 1820 | |||
| 1821 | /* if bit_rate is already set, we believe it */ | ||
| 1822 |
2/2✓ Branch 0 taken 2088 times.
✓ Branch 1 taken 35 times.
|
2123 | if (ic->bit_rate <= 0) { |
| 1823 | 2088 | int64_t bit_rate = 0; | |
| 1824 |
2/2✓ Branch 0 taken 2249 times.
✓ Branch 1 taken 1423 times.
|
3672 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1825 | 2249 | const AVStream *const st = ic->streams[i]; | |
| 1826 | 2249 | const FFStream *const sti = cffstream(st); | |
| 1827 |
4/4✓ Branch 0 taken 1437 times.
✓ Branch 1 taken 812 times.
✓ Branch 2 taken 120 times.
✓ Branch 3 taken 1317 times.
|
2249 | if (st->codecpar->bit_rate <= 0 && sti->avctx->bit_rate > 0) |
| 1828 | 120 | st->codecpar->bit_rate = sti->avctx->bit_rate; | |
| 1829 |
2/2✓ Branch 0 taken 932 times.
✓ Branch 1 taken 1317 times.
|
2249 | if (st->codecpar->bit_rate > 0) { |
| 1830 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 932 times.
|
932 | if (INT64_MAX - st->codecpar->bit_rate < bit_rate) { |
| 1831 | ✗ | bit_rate = 0; | |
| 1832 | ✗ | break; | |
| 1833 | } | ||
| 1834 | 932 | bit_rate += st->codecpar->bit_rate; | |
| 1835 |
4/4✓ Branch 0 taken 1100 times.
✓ Branch 1 taken 217 times.
✓ Branch 2 taken 665 times.
✓ Branch 3 taken 435 times.
|
1317 | } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && sti->codec_info_nb_frames > 1) { |
| 1836 | // If we have a videostream with packets but without a bitrate | ||
| 1837 | // then consider the sum not known | ||
| 1838 | 665 | bit_rate = 0; | |
| 1839 | 665 | break; | |
| 1840 | } | ||
| 1841 | } | ||
| 1842 | 2088 | ic->bit_rate = bit_rate; | |
| 1843 | } | ||
| 1844 | |||
| 1845 | /* if duration is already set, we believe it */ | ||
| 1846 |
1/2✓ Branch 0 taken 2123 times.
✗ Branch 1 not taken.
|
2123 | if (ic->duration == AV_NOPTS_VALUE && |
| 1847 |
2/2✓ Branch 0 taken 939 times.
✓ Branch 1 taken 1184 times.
|
2123 | ic->bit_rate != 0) { |
| 1848 |
2/2✓ Branch 0 taken 905 times.
✓ Branch 1 taken 34 times.
|
939 | int64_t filesize = ic->pb ? avio_size(ic->pb) : 0; |
| 1849 |
2/2✓ Branch 0 taken 896 times.
✓ Branch 1 taken 43 times.
|
939 | if (filesize > si->data_offset) { |
| 1850 | 896 | filesize -= si->data_offset; | |
| 1851 |
2/2✓ Branch 0 taken 935 times.
✓ Branch 1 taken 896 times.
|
1831 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1852 | 935 | AVStream *const st = ic->streams[i]; | |
| 1853 | |||
| 1854 |
1/2✓ Branch 0 taken 935 times.
✗ Branch 1 not taken.
|
935 | if ( st->time_base.num <= INT64_MAX / ic->bit_rate |
| 1855 |
1/2✓ Branch 0 taken 935 times.
✗ Branch 1 not taken.
|
935 | && st->duration == AV_NOPTS_VALUE) { |
| 1856 | 935 | st->duration = av_rescale(filesize, 8LL * st->time_base.den, | |
| 1857 | 935 | ic->bit_rate * | |
| 1858 | 935 | (int64_t) st->time_base.num); | |
| 1859 | 935 | show_warning = 1; | |
| 1860 | } | ||
| 1861 | } | ||
| 1862 | } | ||
| 1863 | } | ||
| 1864 |
2/2✓ Branch 0 taken 896 times.
✓ Branch 1 taken 1227 times.
|
2123 | if (show_warning) |
| 1865 | 896 | av_log(ic, AV_LOG_WARNING, | |
| 1866 | "Estimating duration from bitrate, this may be inaccurate\n"); | ||
| 1867 | 2123 | } | |
| 1868 | |||
| 1869 | #define DURATION_DEFAULT_MAX_READ_SIZE 250000LL | ||
| 1870 | #define DURATION_DEFAULT_MAX_RETRY 6 | ||
| 1871 | #define DURATION_MAX_RETRY 1 | ||
| 1872 | |||
| 1873 | /* only usable for MPEG-PS streams */ | ||
| 1874 | 91 | static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset) | |
| 1875 | { | ||
| 1876 | 91 | FFFormatContext *const si = ffformatcontext(ic); | |
| 1877 | 91 | AVPacket *const pkt = si->pkt; | |
| 1878 | int num, den, read_size, ret; | ||
| 1879 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 91 times.
|
91 | int64_t duration_max_read_size = ic->duration_probesize ? ic->duration_probesize >> DURATION_MAX_RETRY : DURATION_DEFAULT_MAX_READ_SIZE; |
| 1880 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 91 times.
|
91 | int duration_max_retry = ic->duration_probesize ? DURATION_MAX_RETRY : DURATION_DEFAULT_MAX_RETRY; |
| 1881 | 91 | int found_duration = 0; | |
| 1882 | int is_end; | ||
| 1883 | int64_t filesize, offset, duration; | ||
| 1884 | 91 | int retry = 0; | |
| 1885 | |||
| 1886 | /* flush packet queue */ | ||
| 1887 | 91 | ff_flush_packet_queue(ic); | |
| 1888 | |||
| 1889 |
2/2✓ Branch 0 taken 171 times.
✓ Branch 1 taken 91 times.
|
262 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1890 | 171 | AVStream *const st = ic->streams[i]; | |
| 1891 | 171 | FFStream *const sti = ffstream(st); | |
| 1892 | |||
| 1893 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 149 times.
|
171 | if (st->start_time == AV_NOPTS_VALUE && |
| 1894 |
1/2✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
|
22 | sti->first_dts == AV_NOPTS_VALUE && |
| 1895 |
1/2✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
|
22 | st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN) |
| 1896 | 22 | av_log(ic, AV_LOG_WARNING, | |
| 1897 | "start time for stream %d is not set in estimate_timings_from_pts\n", i); | ||
| 1898 | |||
| 1899 |
2/2✓ Branch 0 taken 25 times.
✓ Branch 1 taken 146 times.
|
171 | if (sti->parser) { |
| 1900 | 25 | av_parser_close(sti->parser); | |
| 1901 | 25 | sti->parser = NULL; | |
| 1902 | } | ||
| 1903 | } | ||
| 1904 | |||
| 1905 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 91 times.
|
91 | if (ic->skip_estimate_duration_from_pts) { |
| 1906 | ✗ | av_log(ic, AV_LOG_INFO, "Skipping duration calculation in estimate_timings_from_pts\n"); | |
| 1907 | ✗ | goto skip_duration_calc; | |
| 1908 | } | ||
| 1909 | |||
| 1910 | 91 | av_opt_set_int(ic, "skip_changes", 1, AV_OPT_SEARCH_CHILDREN); | |
| 1911 | /* estimate the end time (duration) */ | ||
| 1912 | /* XXX: may need to support wrapping */ | ||
| 1913 |
1/2✓ Branch 0 taken 91 times.
✗ Branch 1 not taken.
|
91 | filesize = ic->pb ? avio_size(ic->pb) : 0; |
| 1914 | do { | ||
| 1915 | 98 | is_end = found_duration; | |
| 1916 | 98 | offset = filesize - (duration_max_read_size << retry); | |
| 1917 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 56 times.
|
98 | if (offset < 0) |
| 1918 | 42 | offset = 0; | |
| 1919 | |||
| 1920 | 98 | avio_seek(ic->pb, offset, SEEK_SET); | |
| 1921 | 98 | read_size = 0; | |
| 1922 | 7882 | for (;;) { | |
| 1923 | AVStream *st; | ||
| 1924 | FFStream *sti; | ||
| 1925 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 7973 times.
|
7980 | if (read_size >= duration_max_read_size << (FFMAX(retry - 1, 0))) |
| 1926 | 7 | break; | |
| 1927 | |||
| 1928 | do { | ||
| 1929 | 7973 | ret = ff_read_packet(ic, pkt); | |
| 1930 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7973 times.
|
7973 | } while (ret == AVERROR(EAGAIN)); |
| 1931 |
2/2✓ Branch 0 taken 91 times.
✓ Branch 1 taken 7882 times.
|
7973 | if (ret != 0) |
| 1932 | 91 | break; | |
| 1933 | 7882 | read_size += pkt->size; | |
| 1934 | 7882 | st = ic->streams[pkt->stream_index]; | |
| 1935 | 7882 | sti = ffstream(st); | |
| 1936 |
2/2✓ Branch 0 taken 3941 times.
✓ Branch 1 taken 3941 times.
|
7882 | if (pkt->pts != AV_NOPTS_VALUE && |
| 1937 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3941 times.
|
3941 | (st->start_time != AV_NOPTS_VALUE || |
| 1938 | ✗ | sti->first_dts != AV_NOPTS_VALUE)) { | |
| 1939 |
1/2✓ Branch 0 taken 3941 times.
✗ Branch 1 not taken.
|
3941 | if (pkt->duration == 0) { |
| 1940 | 3941 | compute_frame_duration(ic, &num, &den, st, sti->parser, pkt); | |
| 1941 |
3/4✓ Branch 0 taken 3457 times.
✓ Branch 1 taken 484 times.
✓ Branch 2 taken 3457 times.
✗ Branch 3 not taken.
|
3941 | if (den && num) { |
| 1942 | 3457 | pkt->duration = av_rescale_rnd(1, | |
| 1943 | 3457 | num * (int64_t) st->time_base.den, | |
| 1944 | 3457 | den * (int64_t) st->time_base.num, | |
| 1945 | AV_ROUND_DOWN); | ||
| 1946 | } | ||
| 1947 | } | ||
| 1948 | 3941 | duration = pkt->pts + pkt->duration; | |
| 1949 | 3941 | found_duration = 1; | |
| 1950 |
1/2✓ Branch 0 taken 3941 times.
✗ Branch 1 not taken.
|
3941 | if (st->start_time != AV_NOPTS_VALUE) |
| 1951 | 3941 | duration -= st->start_time; | |
| 1952 | else | ||
| 1953 | ✗ | duration -= sti->first_dts; | |
| 1954 |
2/2✓ Branch 0 taken 3931 times.
✓ Branch 1 taken 10 times.
|
3941 | if (duration > 0) { |
| 1955 |
3/4✓ Branch 0 taken 3792 times.
✓ Branch 1 taken 139 times.
✓ Branch 2 taken 3792 times.
✗ Branch 3 not taken.
|
3931 | if (st->duration == AV_NOPTS_VALUE || sti->info->last_duration<= 0 || |
| 1956 |
3/4✓ Branch 0 taken 3096 times.
✓ Branch 1 taken 696 times.
✓ Branch 2 taken 3096 times.
✗ Branch 3 not taken.
|
3792 | (st->duration < duration && FFABS(duration - sti->info->last_duration) < 60LL*st->time_base.den / st->time_base.num)) |
| 1957 | 3235 | st->duration = duration; | |
| 1958 | 3931 | sti->info->last_duration = duration; | |
| 1959 | } | ||
| 1960 | } | ||
| 1961 | 7882 | av_packet_unref(pkt); | |
| 1962 | } | ||
| 1963 | |||
| 1964 | /* check if all audio/video streams have valid duration */ | ||
| 1965 |
2/2✓ Branch 0 taken 91 times.
✓ Branch 1 taken 7 times.
|
98 | if (!is_end) { |
| 1966 | 91 | is_end = 1; | |
| 1967 |
2/2✓ Branch 0 taken 171 times.
✓ Branch 1 taken 91 times.
|
262 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1968 | 171 | const AVStream *const st = ic->streams[i]; | |
| 1969 |
2/2✓ Branch 0 taken 153 times.
✓ Branch 1 taken 18 times.
|
171 | switch (st->codecpar->codec_type) { |
| 1970 | 153 | case AVMEDIA_TYPE_VIDEO: | |
| 1971 | case AVMEDIA_TYPE_AUDIO: | ||
| 1972 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 129 times.
|
153 | if (st->duration == AV_NOPTS_VALUE) |
| 1973 | 24 | is_end = 0; | |
| 1974 | } | ||
| 1975 | } | ||
| 1976 | } | ||
| 1977 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2 times.
|
9 | } while (!is_end && |
| 1978 |
3/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 89 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
|
105 | offset && |
| 1979 | ++retry <= duration_max_retry); | ||
| 1980 | |||
| 1981 | 91 | av_opt_set_int(ic, "skip_changes", 0, AV_OPT_SEARCH_CHILDREN); | |
| 1982 | |||
| 1983 | /* warn about audio/video streams which duration could not be estimated */ | ||
| 1984 |
2/2✓ Branch 0 taken 171 times.
✓ Branch 1 taken 91 times.
|
262 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 1985 | 171 | const AVStream *const st = ic->streams[i]; | |
| 1986 | 171 | const FFStream *const sti = cffstream(st); | |
| 1987 | |||
| 1988 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 139 times.
|
171 | if (st->duration == AV_NOPTS_VALUE) { |
| 1989 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 15 times.
|
32 | switch (st->codecpar->codec_type) { |
| 1990 | 17 | case AVMEDIA_TYPE_VIDEO: | |
| 1991 | case AVMEDIA_TYPE_AUDIO: | ||
| 1992 |
3/4✓ Branch 0 taken 10 times.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
|
17 | if (st->start_time != AV_NOPTS_VALUE || sti->first_dts != AV_NOPTS_VALUE) { |
| 1993 | 7 | av_log(ic, AV_LOG_WARNING, "stream %d : no PTS found at end of file, duration not set\n", i); | |
| 1994 | } else | ||
| 1995 | 10 | av_log(ic, AV_LOG_WARNING, "stream %d : no TS found at start of file, duration not set\n", i); | |
| 1996 | } | ||
| 1997 | } | ||
| 1998 | } | ||
| 1999 | 91 | skip_duration_calc: | |
| 2000 | 91 | fill_all_stream_timings(ic); | |
| 2001 | |||
| 2002 | 91 | avio_seek(ic->pb, old_offset, SEEK_SET); | |
| 2003 |
2/2✓ Branch 0 taken 171 times.
✓ Branch 1 taken 91 times.
|
262 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 2004 | 171 | AVStream *const st = ic->streams[i]; | |
| 2005 | 171 | FFStream *const sti = ffstream(st); | |
| 2006 | |||
| 2007 | 171 | sti->cur_dts = sti->first_dts; | |
| 2008 | 171 | sti->last_IP_pts = AV_NOPTS_VALUE; | |
| 2009 | 171 | sti->last_dts_for_order_check = AV_NOPTS_VALUE; | |
| 2010 |
2/2✓ Branch 0 taken 2907 times.
✓ Branch 1 taken 171 times.
|
3078 | for (int j = 0; j < MAX_REORDER_DELAY + 1; j++) |
| 2011 | 2907 | sti->pts_buffer[j] = AV_NOPTS_VALUE; | |
| 2012 | } | ||
| 2013 | 91 | } | |
| 2014 | |||
| 2015 | /* 1:1 map to AVDurationEstimationMethod */ | ||
| 2016 | static const char *const duration_name[] = { | ||
| 2017 | [AVFMT_DURATION_FROM_PTS] = "pts", | ||
| 2018 | [AVFMT_DURATION_FROM_STREAM] = "stream", | ||
| 2019 | [AVFMT_DURATION_FROM_BITRATE] = "bit rate", | ||
| 2020 | }; | ||
| 2021 | |||
| 2022 | 8136 | static const char *duration_estimate_name(enum AVDurationEstimationMethod method) | |
| 2023 | { | ||
| 2024 | 8136 | return duration_name[method]; | |
| 2025 | } | ||
| 2026 | |||
| 2027 | 8136 | static void estimate_timings(AVFormatContext *ic, int64_t old_offset) | |
| 2028 | { | ||
| 2029 | int64_t file_size; | ||
| 2030 | |||
| 2031 | /* get the file size, if possible */ | ||
| 2032 |
2/2✓ Branch 0 taken 3224 times.
✓ Branch 1 taken 4912 times.
|
8136 | if (ic->iformat->flags & AVFMT_NOFILE) { |
| 2033 | 3224 | file_size = 0; | |
| 2034 | } else { | ||
| 2035 | 4912 | file_size = avio_size(ic->pb); | |
| 2036 | 4912 | file_size = FFMAX(0, file_size); | |
| 2037 | } | ||
| 2038 | |||
| 2039 |
2/2✓ Branch 0 taken 8110 times.
✓ Branch 1 taken 26 times.
|
8136 | if ((!strcmp(ic->iformat->name, "mpeg") || |
| 2040 |
4/4✓ Branch 0 taken 66 times.
✓ Branch 1 taken 8044 times.
✓ Branch 2 taken 91 times.
✓ Branch 3 taken 1 times.
|
8136 | !strcmp(ic->iformat->name, "mpegts")) && |
| 2041 |
1/2✓ Branch 0 taken 91 times.
✗ Branch 1 not taken.
|
91 | file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) { |
| 2042 | /* get accurate estimate from the PTSes */ | ||
| 2043 | 91 | estimate_timings_from_pts(ic, old_offset); | |
| 2044 | 91 | ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS; | |
| 2045 |
2/2✓ Branch 1 taken 5922 times.
✓ Branch 2 taken 2123 times.
|
8045 | } else if (has_duration(ic)) { |
| 2046 | /* at least one component has timings - we use them for all | ||
| 2047 | * the components */ | ||
| 2048 | 5922 | fill_all_stream_timings(ic); | |
| 2049 | /* nut demuxer estimate the duration from PTS */ | ||
| 2050 |
2/2✓ Branch 0 taken 69 times.
✓ Branch 1 taken 5853 times.
|
5922 | if (!strcmp(ic->iformat->name, "nut")) |
| 2051 | 69 | ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS; | |
| 2052 | else | ||
| 2053 | 5853 | ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM; | |
| 2054 | } else { | ||
| 2055 | /* less precise: use bitrate info */ | ||
| 2056 | 2123 | estimate_timings_from_bit_rate(ic); | |
| 2057 | 2123 | ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE; | |
| 2058 | } | ||
| 2059 | 8136 | update_stream_timings(ic); | |
| 2060 | |||
| 2061 |
2/2✓ Branch 0 taken 9038 times.
✓ Branch 1 taken 8136 times.
|
17174 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 2062 | 9038 | AVStream *const st = ic->streams[i]; | |
| 2063 |
1/2✓ Branch 0 taken 9038 times.
✗ Branch 1 not taken.
|
9038 | if (st->time_base.den) |
| 2064 | 9038 | av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i, | |
| 2065 | 9038 | av_ts2timestr(st->start_time, &st->time_base), | |
| 2066 | 9038 | av_ts2timestr(st->duration, &st->time_base)); | |
| 2067 | } | ||
| 2068 | 8136 | av_log(ic, AV_LOG_TRACE, | |
| 2069 | "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n", | ||
| 2070 | 8136 | av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q), | |
| 2071 | 8136 | av_ts2timestr(ic->duration, &AV_TIME_BASE_Q), | |
| 2072 | duration_estimate_name(ic->duration_estimation_method), | ||
| 2073 | 8136 | (int64_t)ic->bit_rate / 1000); | |
| 2074 | 8136 | } | |
| 2075 | |||
| 2076 | 107413 | static int determinable_frame_size(const AVCodecContext *avctx) | |
| 2077 | { | ||
| 2078 |
2/2✓ Branch 0 taken 408 times.
✓ Branch 1 taken 107005 times.
|
107413 | switch(avctx->codec_id) { |
| 2079 | 408 | case AV_CODEC_ID_MP1: | |
| 2080 | case AV_CODEC_ID_MP2: | ||
| 2081 | case AV_CODEC_ID_MP3: | ||
| 2082 | case AV_CODEC_ID_CODEC2: | ||
| 2083 | 408 | return 1; | |
| 2084 | } | ||
| 2085 | |||
| 2086 | 107005 | return 0; | |
| 2087 | } | ||
| 2088 | |||
| 2089 | 443133 | static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr) | |
| 2090 | { | ||
| 2091 | 443133 | const FFStream *const sti = cffstream(st); | |
| 2092 | 443133 | const AVCodecContext *const avctx = sti->avctx; | |
| 2093 | |||
| 2094 | #define FAIL(errmsg) do { \ | ||
| 2095 | if (errmsg_ptr) \ | ||
| 2096 | *errmsg_ptr = errmsg; \ | ||
| 2097 | return 0; \ | ||
| 2098 | } while (0) | ||
| 2099 | |||
| 2100 |
2/2✓ Branch 0 taken 735 times.
✓ Branch 1 taken 442398 times.
|
443133 | if ( avctx->codec_id == AV_CODEC_ID_NONE |
| 2101 |
2/2✓ Branch 0 taken 513 times.
✓ Branch 1 taken 222 times.
|
735 | && avctx->codec_type != AVMEDIA_TYPE_DATA) |
| 2102 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 498 times.
|
513 | FAIL("unknown codec"); |
| 2103 |
4/5✓ Branch 0 taken 128508 times.
✓ Branch 1 taken 312457 times.
✓ Branch 2 taken 665 times.
✓ Branch 3 taken 990 times.
✗ Branch 4 not taken.
|
442620 | switch (avctx->codec_type) { |
| 2104 | 128508 | case AVMEDIA_TYPE_AUDIO: | |
| 2105 |
4/4✓ Branch 0 taken 107413 times.
✓ Branch 1 taken 21095 times.
✓ Branch 3 taken 408 times.
✓ Branch 4 taken 107005 times.
|
128508 | if (!avctx->frame_size && determinable_frame_size(avctx)) |
| 2106 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 406 times.
|
408 | FAIL("unspecified frame size"); |
| 2107 |
1/2✓ Branch 0 taken 128100 times.
✗ Branch 1 not taken.
|
128100 | if (sti->info->found_decoder >= 0 && |
| 2108 |
2/2✓ Branch 0 taken 2828 times.
✓ Branch 1 taken 125272 times.
|
128100 | avctx->sample_fmt == AV_SAMPLE_FMT_NONE) |
| 2109 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2828 times.
|
2828 | FAIL("unspecified sample format"); |
| 2110 |
2/2✓ Branch 0 taken 154 times.
✓ Branch 1 taken 125118 times.
|
125272 | if (!avctx->sample_rate) |
| 2111 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 148 times.
|
154 | FAIL("unspecified sample rate"); |
| 2112 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 125096 times.
|
125118 | if (!avctx->ch_layout.nb_channels) |
| 2113 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | FAIL("unspecified number of channels"); |
| 2114 |
5/6✓ Branch 0 taken 125096 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 81469 times.
✓ Branch 3 taken 43627 times.
✓ Branch 4 taken 110 times.
✓ Branch 5 taken 81359 times.
|
125096 | if (sti->info->found_decoder >= 0 && !sti->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS) |
| 2115 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 110 times.
|
110 | FAIL("no decodable DTS frames"); |
| 2116 | 124986 | break; | |
| 2117 | 312457 | case AVMEDIA_TYPE_VIDEO: | |
| 2118 |
2/2✓ Branch 0 taken 13293 times.
✓ Branch 1 taken 299164 times.
|
312457 | if (!avctx->width) |
| 2119 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 13281 times.
|
13293 | FAIL("unspecified size"); |
| 2120 |
4/4✓ Branch 0 taken 298892 times.
✓ Branch 1 taken 272 times.
✓ Branch 2 taken 4484 times.
✓ Branch 3 taken 294408 times.
|
299164 | if (sti->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE) |
| 2121 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 4481 times.
|
4484 | FAIL("unspecified pixel format"); |
| 2122 |
4/4✓ Branch 0 taken 294580 times.
✓ Branch 1 taken 100 times.
✓ Branch 2 taken 86 times.
✓ Branch 3 taken 294494 times.
|
294680 | if (st->codecpar->codec_id == AV_CODEC_ID_RV30 || st->codecpar->codec_id == AV_CODEC_ID_RV40) |
| 2123 |
4/6✓ Branch 0 taken 186 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 186 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 67 times.
✓ Branch 5 taken 119 times.
|
186 | if (!st->sample_aspect_ratio.num && !st->codecpar->sample_aspect_ratio.num && !sti->codec_info_nb_frames) |
| 2124 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 67 times.
|
67 | FAIL("no frame in rv30/40 and no sar"); |
| 2125 | 294613 | break; | |
| 2126 | 665 | case AVMEDIA_TYPE_SUBTITLE: | |
| 2127 |
4/4✓ Branch 0 taken 35 times.
✓ Branch 1 taken 630 times.
✓ Branch 2 taken 21 times.
✓ Branch 3 taken 14 times.
|
665 | if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width) |
| 2128 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | FAIL("unspecified size"); |
| 2129 | 644 | break; | |
| 2130 | 990 | case AVMEDIA_TYPE_DATA: | |
| 2131 |
2/2✓ Branch 0 taken 222 times.
✓ Branch 1 taken 768 times.
|
990 | if (avctx->codec_id == AV_CODEC_ID_NONE) return 1; |
| 2132 | } | ||
| 2133 | |||
| 2134 | 421011 | return 1; | |
| 2135 | } | ||
| 2136 | |||
| 2137 | /* returns 1 or 0 if or if not decoded data was returned, or a negative error */ | ||
| 2138 | 205678 | static int try_decode_frame(AVFormatContext *s, AVStream *st, | |
| 2139 | const AVPacket *pkt, AVDictionary **options) | ||
| 2140 | { | ||
| 2141 | 205678 | FFStream *const sti = ffstream(st); | |
| 2142 | 205678 | AVCodecContext *const avctx = sti->avctx; | |
| 2143 | const AVCodec *codec; | ||
| 2144 | 205678 | int got_picture = 1, ret = 0; | |
| 2145 | 205678 | AVFrame *frame = av_frame_alloc(); | |
| 2146 | AVSubtitle subtitle; | ||
| 2147 | 205678 | int do_skip_frame = 0; | |
| 2148 | enum AVDiscard skip_frame; | ||
| 2149 | 205678 | int pkt_to_send = pkt->size > 0; | |
| 2150 | |||
| 2151 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 205678 times.
|
205678 | if (!frame) |
| 2152 | ✗ | return AVERROR(ENOMEM); | |
| 2153 | |||
| 2154 |
2/2✓ Branch 1 taken 1762 times.
✓ Branch 2 taken 203916 times.
|
205678 | if (!avcodec_is_open(avctx) && |
| 2155 |
1/2✓ Branch 0 taken 1762 times.
✗ Branch 1 not taken.
|
1762 | sti->info->found_decoder <= 0 && |
| 2156 |
4/4✓ Branch 0 taken 270 times.
✓ Branch 1 taken 1492 times.
✓ Branch 2 taken 57 times.
✓ Branch 3 taken 213 times.
|
1762 | (st->codecpar->codec_id != -sti->info->found_decoder || !st->codecpar->codec_id)) { |
| 2157 | 1549 | AVDictionary *thread_opt = NULL; | |
| 2158 | |||
| 2159 | 1549 | codec = find_probe_decoder(s, st, st->codecpar->codec_id); | |
| 2160 | |||
| 2161 |
2/2✓ Branch 0 taken 81 times.
✓ Branch 1 taken 1468 times.
|
1549 | if (!codec) { |
| 2162 | 81 | sti->info->found_decoder = -st->codecpar->codec_id; | |
| 2163 | 81 | ret = -1; | |
| 2164 | 83 | goto fail; | |
| 2165 | } | ||
| 2166 | |||
| 2167 | /* Force thread count to 1 since the H.264 decoder will not extract | ||
| 2168 | * SPS and PPS to extradata during multi-threaded decoding. */ | ||
| 2169 |
2/2✓ Branch 0 taken 167 times.
✓ Branch 1 taken 1301 times.
|
1468 | av_dict_set(options ? options : &thread_opt, "threads", "1", 0); |
| 2170 | /* Force lowres to 0. The decoder might reduce the video size by the | ||
| 2171 | * lowres factor, and we don't want that propagated to the stream's | ||
| 2172 | * codecpar */ | ||
| 2173 |
2/2✓ Branch 0 taken 167 times.
✓ Branch 1 taken 1301 times.
|
1468 | av_dict_set(options ? options : &thread_opt, "lowres", "0", 0); |
| 2174 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1468 times.
|
1468 | if (s->codec_whitelist) |
| 2175 | ✗ | av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0); | |
| 2176 |
2/2✓ Branch 0 taken 167 times.
✓ Branch 1 taken 1301 times.
|
1468 | ret = avcodec_open2(avctx, codec, options ? options : &thread_opt); |
| 2177 |
2/2✓ Branch 0 taken 167 times.
✓ Branch 1 taken 1301 times.
|
1468 | if (!options) |
| 2178 | 167 | av_dict_free(&thread_opt); | |
| 2179 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1466 times.
|
1468 | if (ret < 0) { |
| 2180 | 2 | sti->info->found_decoder = -avctx->codec_id; | |
| 2181 | 2 | goto fail; | |
| 2182 | } | ||
| 2183 | 1466 | sti->info->found_decoder = 1; | |
| 2184 |
2/2✓ Branch 0 taken 7154 times.
✓ Branch 1 taken 196975 times.
|
204129 | } else if (!sti->info->found_decoder) |
| 2185 | 7154 | sti->info->found_decoder = 1; | |
| 2186 | |||
| 2187 |
2/2✓ Branch 0 taken 213 times.
✓ Branch 1 taken 205382 times.
|
205595 | if (sti->info->found_decoder < 0) { |
| 2188 | 213 | ret = -1; | |
| 2189 | 213 | goto fail; | |
| 2190 | } | ||
| 2191 | |||
| 2192 |
2/2✓ Branch 1 taken 112480 times.
✓ Branch 2 taken 92902 times.
|
205382 | if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) { |
| 2193 | 112480 | do_skip_frame = 1; | |
| 2194 | 112480 | skip_frame = avctx->skip_frame; | |
| 2195 | 112480 | avctx->skip_frame = AVDISCARD_ALL; | |
| 2196 | } | ||
| 2197 | |||
| 2198 |
5/6✓ Branch 0 taken 8477 times.
✓ Branch 1 taken 4880 times.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 4852 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 205390 times.
|
419277 | while ((pkt_to_send || (!pkt->data && got_picture)) && |
| 2199 |
4/4✓ Branch 0 taken 13357 times.
✓ Branch 1 taken 200538 times.
✓ Branch 2 taken 5950 times.
✓ Branch 3 taken 199440 times.
|
419285 | ret >= 0 && |
| 2200 |
2/2✓ Branch 2 taken 2264 times.
✓ Branch 3 taken 197176 times.
|
404830 | (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) || |
| 2201 |
2/2✓ Branch 0 taken 194153 times.
✓ Branch 1 taken 3023 times.
|
197176 | (!sti->codec_info_nb_frames && |
| 2202 |
2/2✓ Branch 0 taken 549 times.
✓ Branch 1 taken 2474 times.
|
3023 | (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) { |
| 2203 | 8763 | got_picture = 0; | |
| 2204 |
2/2✓ Branch 0 taken 984 times.
✓ Branch 1 taken 7779 times.
|
8763 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO || |
| 2205 |
2/2✓ Branch 0 taken 977 times.
✓ Branch 1 taken 7 times.
|
984 | avctx->codec_type == AVMEDIA_TYPE_AUDIO) { |
| 2206 | 8756 | ret = avcodec_send_packet(avctx, pkt); | |
| 2207 |
5/6✓ Branch 0 taken 259 times.
✓ Branch 1 taken 8497 times.
✓ Branch 2 taken 259 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 250 times.
✓ Branch 5 taken 9 times.
|
8756 | if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) |
| 2208 | 250 | break; | |
| 2209 |
2/2✓ Branch 0 taken 8497 times.
✓ Branch 1 taken 9 times.
|
8506 | if (ret >= 0) |
| 2210 | 8497 | pkt_to_send = 0; | |
| 2211 | 8506 | ret = avcodec_receive_frame(avctx, frame); | |
| 2212 |
2/2✓ Branch 0 taken 3315 times.
✓ Branch 1 taken 5191 times.
|
8506 | if (ret >= 0) |
| 2213 | 3315 | got_picture = 1; | |
| 2214 |
4/4✓ Branch 0 taken 3343 times.
✓ Branch 1 taken 5163 times.
✓ Branch 2 taken 28 times.
✓ Branch 3 taken 3315 times.
|
8506 | if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) |
| 2215 | 5191 | ret = 0; | |
| 2216 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | } else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) { |
| 2217 | 7 | ret = avcodec_decode_subtitle2(avctx, &subtitle, | |
| 2218 | &got_picture, pkt); | ||
| 2219 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5 times.
|
7 | if (got_picture) |
| 2220 | 2 | avsubtitle_free(&subtitle); | |
| 2221 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | if (ret >= 0) |
| 2222 | 7 | pkt_to_send = 0; | |
| 2223 | } | ||
| 2224 |
1/2✓ Branch 0 taken 8513 times.
✗ Branch 1 not taken.
|
8513 | if (ret >= 0) { |
| 2225 |
2/2✓ Branch 0 taken 3317 times.
✓ Branch 1 taken 5196 times.
|
8513 | if (got_picture) |
| 2226 | 3317 | sti->nb_decoded_frames++; | |
| 2227 | 8513 | ret = got_picture; | |
| 2228 | } | ||
| 2229 | } | ||
| 2230 | |||
| 2231 | 205132 | fail: | |
| 2232 |
2/2✓ Branch 0 taken 112480 times.
✓ Branch 1 taken 93198 times.
|
205678 | if (do_skip_frame) { |
| 2233 | 112480 | avctx->skip_frame = skip_frame; | |
| 2234 | } | ||
| 2235 | |||
| 2236 | 205678 | av_frame_free(&frame); | |
| 2237 | 205678 | return ret; | |
| 2238 | } | ||
| 2239 | |||
| 2240 | 87 | static int chapter_start_cmp(const void *p1, const void *p2) | |
| 2241 | { | ||
| 2242 | 87 | const AVChapter *const ch1 = *(AVChapter**)p1; | |
| 2243 | 87 | const AVChapter *const ch2 = *(AVChapter**)p2; | |
| 2244 | 87 | int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base); | |
| 2245 |
1/2✓ Branch 0 taken 87 times.
✗ Branch 1 not taken.
|
87 | if (delta) |
| 2246 | 87 | return delta; | |
| 2247 | ✗ | return FFDIFFSIGN(ch1->id, ch2->id); | |
| 2248 | } | ||
| 2249 | |||
| 2250 | 8136 | static int compute_chapters_end(AVFormatContext *s) | |
| 2251 | { | ||
| 2252 | 8136 | int64_t max_time = 0; | |
| 2253 | AVChapter **timetable; | ||
| 2254 | |||
| 2255 |
2/2✓ Branch 0 taken 8080 times.
✓ Branch 1 taken 56 times.
|
8136 | if (!s->nb_chapters) |
| 2256 | 8080 | return 0; | |
| 2257 | |||
| 2258 |
2/4✓ Branch 0 taken 56 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 56 times.
✗ Branch 3 not taken.
|
56 | if (s->duration > 0 && s->start_time < INT64_MAX - s->duration) |
| 2259 | 56 | max_time = s->duration + | |
| 2260 |
2/2✓ Branch 0 taken 33 times.
✓ Branch 1 taken 23 times.
|
56 | ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time); |
| 2261 | |||
| 2262 | 56 | timetable = av_memdup(s->chapters, s->nb_chapters * sizeof(*timetable)); | |
| 2263 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 56 times.
|
56 | if (!timetable) |
| 2264 | ✗ | return AVERROR(ENOMEM); | |
| 2265 | 56 | qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp); | |
| 2266 | |||
| 2267 |
2/2✓ Branch 0 taken 131 times.
✓ Branch 1 taken 56 times.
|
187 | for (unsigned i = 0; i < s->nb_chapters; i++) |
| 2268 |
2/2✓ Branch 0 taken 50 times.
✓ Branch 1 taken 81 times.
|
131 | if (timetable[i]->end == AV_NOPTS_VALUE) { |
| 2269 | 50 | AVChapter *const ch = timetable[i]; | |
| 2270 | 50 | int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, | |
| 2271 | ch->time_base) | ||
| 2272 |
1/2✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
|
50 | : INT64_MAX; |
| 2273 | |||
| 2274 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 29 times.
|
50 | if (i + 1 < s->nb_chapters) { |
| 2275 | 21 | const AVChapter *const ch1 = timetable[i + 1]; | |
| 2276 | 21 | int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, | |
| 2277 | ch->time_base); | ||
| 2278 |
2/4✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 21 times.
✗ Branch 3 not taken.
|
21 | if (next_start > ch->start && next_start < end) |
| 2279 | 21 | end = next_start; | |
| 2280 | } | ||
| 2281 |
2/4✓ Branch 0 taken 50 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 50 times.
|
50 | ch->end = (end == INT64_MAX || end < ch->start) ? ch->start : end; |
| 2282 | } | ||
| 2283 | 56 | av_free(timetable); | |
| 2284 | 56 | return 0; | |
| 2285 | } | ||
| 2286 | |||
| 2287 | 19685808 | static int get_std_framerate(int i) | |
| 2288 | { | ||
| 2289 |
2/2✓ Branch 0 taken 17883404 times.
✓ Branch 1 taken 1802404 times.
|
19685808 | if (i < 30*12) |
| 2290 | 17883404 | return (i + 1) * 1001; | |
| 2291 | 1802404 | i -= 30*12; | |
| 2292 | |||
| 2293 |
2/2✓ Branch 0 taken 1370499 times.
✓ Branch 1 taken 431905 times.
|
1802404 | if (i < 30) |
| 2294 | 1370499 | return (i + 31) * 1001 * 12; | |
| 2295 | 431905 | i -= 30; | |
| 2296 | |||
| 2297 |
2/2✓ Branch 0 taken 137899 times.
✓ Branch 1 taken 294006 times.
|
431905 | if (i < 3) |
| 2298 | 137899 | return ((const int[]) { 80, 120, 240})[i] * 1001 * 12; | |
| 2299 | |||
| 2300 | 294006 | i -= 3; | |
| 2301 | |||
| 2302 | 294006 | return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12; | |
| 2303 | } | ||
| 2304 | |||
| 2305 | /* Is the time base unreliable? | ||
| 2306 | * This is a heuristic to balance between quick acceptance of the values in | ||
| 2307 | * the headers vs. some extra checks. | ||
| 2308 | * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps. | ||
| 2309 | * MPEG-2 commonly misuses field repeat flags to store different framerates. | ||
| 2310 | * And there are "variable" fps files this needs to detect as well. */ | ||
| 2311 | 217647 | static int tb_unreliable(AVFormatContext *ic, AVStream *st) | |
| 2312 | { | ||
| 2313 | 217647 | FFStream *const sti = ffstream(st); | |
| 2314 | 217647 | const AVCodecDescriptor *desc = sti->codec_desc; | |
| 2315 | 217647 | AVCodecContext *c = sti->avctx; | |
| 2316 |
4/4✓ Branch 0 taken 217134 times.
✓ Branch 1 taken 513 times.
✓ Branch 2 taken 21806 times.
✓ Branch 3 taken 195328 times.
|
217647 | AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 }; |
| 2317 | 217647 | AVRational time_base = c->framerate.num ? av_inv_q(av_mul_q(c->framerate, mul)) | |
| 2318 | /* NOHEADER check added to not break existing behavior */ | ||
| 2319 |
2/2✓ Branch 0 taken 19196 times.
✓ Branch 1 taken 198451 times.
|
217647 | : (((ic->ctx_flags & AVFMTCTX_NOHEADER) || |
| 2320 |
2/2✓ Branch 0 taken 47513 times.
✓ Branch 1 taken 31232 times.
|
78745 | st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ? (AVRational){0, 1} |
| 2321 |
2/2✓ Branch 0 taken 78745 times.
✓ Branch 1 taken 119706 times.
|
198451 | : st->time_base); |
| 2322 | |||
| 2323 |
2/2✓ Branch 0 taken 25745 times.
✓ Branch 1 taken 191902 times.
|
217647 | if (time_base.den >= 101LL * time_base.num || |
| 2324 |
2/2✓ Branch 0 taken 25232 times.
✓ Branch 1 taken 513 times.
|
25745 | time_base.den < 5LL * time_base.num || |
| 2325 | // c->codec_tag == AV_RL32("DIVX") || | ||
| 2326 | // c->codec_tag == AV_RL32("XVID") || | ||
| 2327 |
2/2✓ Branch 0 taken 25025 times.
✓ Branch 1 taken 207 times.
|
25232 | c->codec_tag == AV_RL32("mp4v") || |
| 2328 |
2/2✓ Branch 0 taken 15831 times.
✓ Branch 1 taken 9194 times.
|
25025 | c->codec_id == AV_CODEC_ID_MPEG2VIDEO || |
| 2329 |
2/2✓ Branch 0 taken 15301 times.
✓ Branch 1 taken 530 times.
|
15831 | c->codec_id == AV_CODEC_ID_GIF || |
| 2330 |
2/2✓ Branch 0 taken 14023 times.
✓ Branch 1 taken 1278 times.
|
15301 | c->codec_id == AV_CODEC_ID_HEVC || |
| 2331 |
2/2✓ Branch 0 taken 3797 times.
✓ Branch 1 taken 10226 times.
|
14023 | c->codec_id == AV_CODEC_ID_H264) |
| 2332 | 207421 | return 1; | |
| 2333 | 10226 | return 0; | |
| 2334 | } | ||
| 2335 | |||
| 2336 | 147990 | int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts) | |
| 2337 | { | ||
| 2338 | 147990 | FFStream *const sti = ffstream(st); | |
| 2339 | 147990 | FFStreamInfo *info = sti->info; | |
| 2340 | 147990 | int64_t last = info->last_dts; | |
| 2341 | |||
| 2342 |
6/6✓ Branch 0 taken 131369 times.
✓ Branch 1 taken 16621 times.
✓ Branch 2 taken 125030 times.
✓ Branch 3 taken 6339 times.
✓ Branch 4 taken 125004 times.
✓ Branch 5 taken 26 times.
|
147990 | if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last |
| 2343 |
1/2✓ Branch 0 taken 125004 times.
✗ Branch 1 not taken.
|
125004 | && ts - (uint64_t)last < INT64_MAX) { |
| 2344 |
2/2✓ Branch 1 taken 6615 times.
✓ Branch 2 taken 118389 times.
|
125004 | double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base); |
| 2345 | 125004 | int64_t duration = ts - last; | |
| 2346 | |||
| 2347 |
2/2✓ Branch 0 taken 4101 times.
✓ Branch 1 taken 120903 times.
|
125004 | if (!info->duration_error) |
| 2348 | 4101 | info->duration_error = av_mallocz(sizeof(info->duration_error[0])*2); | |
| 2349 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 125004 times.
|
125004 | if (!info->duration_error) |
| 2350 | ✗ | return AVERROR(ENOMEM); | |
| 2351 | |||
| 2352 | // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) | ||
| 2353 | // av_log(NULL, AV_LOG_ERROR, "%f\n", dts); | ||
| 2354 |
2/2✓ Branch 0 taken 49876596 times.
✓ Branch 1 taken 125004 times.
|
50001600 | for (int i = 0; i < MAX_STD_TIMEBASES; i++) { |
| 2355 |
2/2✓ Branch 0 taken 19295131 times.
✓ Branch 1 taken 30581465 times.
|
49876596 | if (info->duration_error[0][1][i] < 1e10) { |
| 2356 | 19295131 | int framerate = get_std_framerate(i); | |
| 2357 | 19295131 | double sdts = dts*framerate/(1001*12); | |
| 2358 |
2/2✓ Branch 0 taken 38590262 times.
✓ Branch 1 taken 19295131 times.
|
57885393 | for (int j = 0; j < 2; j++) { |
| 2359 | 38590262 | int64_t ticks = llrint(sdts+j*0.5); | |
| 2360 | 38590262 | double error = sdts - ticks + j*0.5; | |
| 2361 | 38590262 | info->duration_error[j][0][i] += error; | |
| 2362 | 38590262 | info->duration_error[j][1][i] += error*error; | |
| 2363 | } | ||
| 2364 | } | ||
| 2365 | } | ||
| 2366 |
1/2✓ Branch 0 taken 125004 times.
✗ Branch 1 not taken.
|
125004 | if (info->rfps_duration_sum <= INT64_MAX - duration) { |
| 2367 | 125004 | info->duration_count++; | |
| 2368 | 125004 | info->rfps_duration_sum += duration; | |
| 2369 | } | ||
| 2370 | |||
| 2371 |
2/2✓ Branch 0 taken 11348 times.
✓ Branch 1 taken 113656 times.
|
125004 | if (info->duration_count % 10 == 0) { |
| 2372 | 11348 | int n = info->duration_count; | |
| 2373 |
2/2✓ Branch 0 taken 4527852 times.
✓ Branch 1 taken 11348 times.
|
4539200 | for (int i = 0; i < MAX_STD_TIMEBASES; i++) { |
| 2374 |
2/2✓ Branch 0 taken 1840265 times.
✓ Branch 1 taken 2687587 times.
|
4527852 | if (info->duration_error[0][1][i] < 1e10) { |
| 2375 | 1840265 | double a0 = info->duration_error[0][0][i] / n; | |
| 2376 | 1840265 | double error0 = info->duration_error[0][1][i] / n - a0*a0; | |
| 2377 | 1840265 | double a1 = info->duration_error[1][0][i] / n; | |
| 2378 | 1840265 | double error1 = info->duration_error[1][1][i] / n - a1*a1; | |
| 2379 |
4/4✓ Branch 0 taken 1507580 times.
✓ Branch 1 taken 332685 times.
✓ Branch 2 taken 1407009 times.
✓ Branch 3 taken 100571 times.
|
1840265 | if (error0 > 0.04 && error1 > 0.04) { |
| 2380 | 1407009 | info->duration_error[0][1][i] = 2e10; | |
| 2381 | 1407009 | info->duration_error[1][1][i] = 2e10; | |
| 2382 | } | ||
| 2383 | } | ||
| 2384 | } | ||
| 2385 | } | ||
| 2386 | |||
| 2387 | // ignore the first 4 values, they might have some random jitter | ||
| 2388 |
3/4✓ Branch 0 taken 112792 times.
✓ Branch 1 taken 12212 times.
✓ Branch 4 taken 112792 times.
✗ Branch 5 not taken.
|
125004 | if (info->duration_count > 3 && is_relative(ts) == is_relative(last)) |
| 2389 | 112792 | info->duration_gcd = av_gcd(info->duration_gcd, duration); | |
| 2390 | } | ||
| 2391 |
2/2✓ Branch 0 taken 131369 times.
✓ Branch 1 taken 16621 times.
|
147990 | if (ts != AV_NOPTS_VALUE) |
| 2392 | 131369 | info->last_dts = ts; | |
| 2393 | |||
| 2394 | 147990 | return 0; | |
| 2395 | } | ||
| 2396 | |||
| 2397 | 8705 | void ff_rfps_calculate(AVFormatContext *ic) | |
| 2398 | { | ||
| 2399 |
2/2✓ Branch 0 taken 9822 times.
✓ Branch 1 taken 8705 times.
|
18527 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 2400 | 9822 | AVStream *const st = ic->streams[i]; | |
| 2401 | 9822 | FFStream *const sti = ffstream(st); | |
| 2402 | |||
| 2403 |
2/2✓ Branch 0 taken 2855 times.
✓ Branch 1 taken 6967 times.
|
9822 | if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO) |
| 2404 | 2855 | continue; | |
| 2405 | // the check for tb_unreliable() is not completely correct, since this is not about handling | ||
| 2406 | // an unreliable/inexact time base, but a time base that is finer than necessary, as e.g. | ||
| 2407 | // ipmovie.c produces. | ||
| 2408 |
8/8✓ Branch 1 taken 5545 times.
✓ Branch 2 taken 1422 times.
✓ Branch 3 taken 3530 times.
✓ Branch 4 taken 2015 times.
✓ Branch 5 taken 327 times.
✓ Branch 6 taken 3203 times.
✓ Branch 7 taken 171 times.
✓ Branch 8 taken 156 times.
|
6967 | if (tb_unreliable(ic, st) && sti->info->duration_count > 15 && sti->info->duration_gcd > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !st->r_frame_rate.num && |
| 2409 |
1/2✓ Branch 0 taken 171 times.
✗ Branch 1 not taken.
|
171 | sti->info->duration_gcd < INT64_MAX / st->time_base.num) |
| 2410 | 171 | av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * sti->info->duration_gcd, INT_MAX); | |
| 2411 |
4/4✓ Branch 0 taken 4063 times.
✓ Branch 1 taken 2904 times.
✓ Branch 2 taken 420 times.
✓ Branch 3 taken 3643 times.
|
6967 | if (sti->info->duration_count > 1 && !st->r_frame_rate.num |
| 2412 |
2/2✓ Branch 1 taken 311 times.
✓ Branch 2 taken 109 times.
|
420 | && tb_unreliable(ic, st)) { |
| 2413 | 311 | int num = 0; | |
| 2414 | 311 | double best_error = 0.01; | |
| 2415 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 311 times.
|
311 | AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base); |
| 2416 | |||
| 2417 |
2/2✓ Branch 0 taken 124089 times.
✓ Branch 1 taken 311 times.
|
124400 | for (int j = 0; j < MAX_STD_TIMEBASES; j++) { |
| 2418 |
2/2✓ Branch 0 taken 91371 times.
✓ Branch 1 taken 32718 times.
|
124089 | if (sti->info->codec_info_duration && |
| 2419 |
2/2✓ Branch 2 taken 9961 times.
✓ Branch 3 taken 81410 times.
|
91371 | sti->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j)) |
| 2420 | 9961 | continue; | |
| 2421 |
4/4✓ Branch 0 taken 32718 times.
✓ Branch 1 taken 81410 times.
✓ Branch 3 taken 902 times.
✓ Branch 4 taken 31816 times.
|
114128 | if (!sti->info->codec_info_duration && get_std_framerate(j) < 1001*12) |
| 2422 | 902 | continue; | |
| 2423 | |||
| 2424 |
2/2✓ Branch 2 taken 53267 times.
✓ Branch 3 taken 59959 times.
|
113226 | if (av_q2d(st->time_base) * sti->info->rfps_duration_sum / sti->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j)) |
| 2425 | 53267 | continue; | |
| 2426 | |||
| 2427 |
2/2✓ Branch 0 taken 119918 times.
✓ Branch 1 taken 59959 times.
|
179877 | for (int k = 0; k < 2; k++) { |
| 2428 | 119918 | int n = sti->info->duration_count; | |
| 2429 | 119918 | double a = sti->info->duration_error[k][0][j] / n; | |
| 2430 | 119918 | double error = sti->info->duration_error[k][1][j]/n - a*a; | |
| 2431 | |||
| 2432 |
4/4✓ Branch 0 taken 4537 times.
✓ Branch 1 taken 115381 times.
✓ Branch 2 taken 4466 times.
✓ Branch 3 taken 71 times.
|
119918 | if (error < best_error && best_error> 0.000000001) { |
| 2433 | 4466 | best_error= error; | |
| 2434 | 4466 | num = get_std_framerate(j); | |
| 2435 | } | ||
| 2436 |
2/2✓ Branch 0 taken 24807 times.
✓ Branch 1 taken 95111 times.
|
119918 | if (error < 0.02) |
| 2437 | 24807 | av_log(ic, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error); | |
| 2438 | } | ||
| 2439 | } | ||
| 2440 | // do not increase frame rate by more than 1 % in order to match a standard rate. | ||
| 2441 |
5/6✓ Branch 0 taken 305 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 305 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 303 times.
✓ Branch 6 taken 2 times.
|
311 | if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate))) |
| 2442 | 303 | av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX); | |
| 2443 | } | ||
| 2444 |
2/2✓ Branch 0 taken 1159 times.
✓ Branch 1 taken 5808 times.
|
6967 | if ( !st->avg_frame_rate.num |
| 2445 |
4/4✓ Branch 0 taken 327 times.
✓ Branch 1 taken 832 times.
✓ Branch 2 taken 322 times.
✓ Branch 3 taken 5 times.
|
1159 | && st->r_frame_rate.num && sti->info->rfps_duration_sum |
| 2446 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 243 times.
|
322 | && sti->info->codec_info_duration <= 0 |
| 2447 |
2/2✓ Branch 0 taken 76 times.
✓ Branch 1 taken 3 times.
|
79 | && sti->info->duration_count > 2 |
| 2448 |
2/2✓ Branch 2 taken 61 times.
✓ Branch 3 taken 15 times.
|
76 | && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - sti->info->rfps_duration_sum / (double)sti->info->duration_count) <= 1.0 |
| 2449 | ) { | ||
| 2450 | 61 | av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n"); | |
| 2451 | 61 | st->avg_frame_rate = st->r_frame_rate; | |
| 2452 | } | ||
| 2453 | |||
| 2454 | 6967 | av_freep(&sti->info->duration_error); | |
| 2455 | 6967 | sti->info->last_dts = AV_NOPTS_VALUE; | |
| 2456 | 6967 | sti->info->duration_count = 0; | |
| 2457 | 6967 | sti->info->rfps_duration_sum = 0; | |
| 2458 | } | ||
| 2459 | 8705 | } | |
| 2460 | |||
| 2461 | 9489 | static int extract_extradata_check(AVStream *st) | |
| 2462 | { | ||
| 2463 | 9489 | const AVBitStreamFilter *const f = av_bsf_get_by_name("extract_extradata"); | |
| 2464 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9489 times.
|
9489 | if (!f) |
| 2465 | ✗ | return 0; | |
| 2466 | |||
| 2467 |
1/2✓ Branch 0 taken 9489 times.
✗ Branch 1 not taken.
|
9489 | if (f->codec_ids) { |
| 2468 | const enum AVCodecID *ids; | ||
| 2469 |
2/2✓ Branch 0 taken 109544 times.
✓ Branch 1 taken 8540 times.
|
118084 | for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++) |
| 2470 |
2/2✓ Branch 0 taken 949 times.
✓ Branch 1 taken 108595 times.
|
109544 | if (*ids == st->codecpar->codec_id) |
| 2471 | 949 | return 1; | |
| 2472 | } | ||
| 2473 | |||
| 2474 | 8540 | return 0; | |
| 2475 | } | ||
| 2476 | |||
| 2477 | 7462 | static int extract_extradata_init(AVStream *st) | |
| 2478 | { | ||
| 2479 | 7462 | FFStream *const sti = ffstream(st); | |
| 2480 | const AVBitStreamFilter *f; | ||
| 2481 | int ret; | ||
| 2482 | |||
| 2483 | 7462 | f = av_bsf_get_by_name("extract_extradata"); | |
| 2484 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7462 times.
|
7462 | if (!f) |
| 2485 | ✗ | goto finish; | |
| 2486 | |||
| 2487 | /* check that the codec id is supported */ | ||
| 2488 | 7462 | ret = extract_extradata_check(st); | |
| 2489 |
2/2✓ Branch 0 taken 6623 times.
✓ Branch 1 taken 839 times.
|
7462 | if (!ret) |
| 2490 | 6623 | goto finish; | |
| 2491 | |||
| 2492 | 839 | av_bsf_free(&sti->extract_extradata.bsf); | |
| 2493 | 839 | ret = av_bsf_alloc(f, &sti->extract_extradata.bsf); | |
| 2494 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 839 times.
|
839 | if (ret < 0) |
| 2495 | ✗ | return ret; | |
| 2496 | |||
| 2497 | 839 | ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in, | |
| 2498 | 839 | st->codecpar); | |
| 2499 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 839 times.
|
839 | if (ret < 0) |
| 2500 | ✗ | goto fail; | |
| 2501 | |||
| 2502 | 839 | sti->extract_extradata.bsf->time_base_in = st->time_base; | |
| 2503 | |||
| 2504 | 839 | ret = av_bsf_init(sti->extract_extradata.bsf); | |
| 2505 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 839 times.
|
839 | if (ret < 0) |
| 2506 | ✗ | goto fail; | |
| 2507 | |||
| 2508 | 839 | finish: | |
| 2509 | 7462 | sti->extract_extradata.inited = 1; | |
| 2510 | |||
| 2511 | 7462 | return 0; | |
| 2512 | ✗ | fail: | |
| 2513 | ✗ | av_bsf_free(&sti->extract_extradata.bsf); | |
| 2514 | ✗ | return ret; | |
| 2515 | } | ||
| 2516 | |||
| 2517 | 168227 | static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt) | |
| 2518 | { | ||
| 2519 | 168227 | FFStream *const sti = ffstream(st); | |
| 2520 | 168227 | AVPacket *const pkt_ref = si->parse_pkt; | |
| 2521 | int ret; | ||
| 2522 | |||
| 2523 |
2/2✓ Branch 0 taken 7462 times.
✓ Branch 1 taken 160765 times.
|
168227 | if (!sti->extract_extradata.inited) { |
| 2524 | 7462 | ret = extract_extradata_init(st); | |
| 2525 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7462 times.
|
7462 | if (ret < 0) |
| 2526 | ✗ | return ret; | |
| 2527 | } | ||
| 2528 | |||
| 2529 |
3/4✓ Branch 0 taken 168227 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 166993 times.
✓ Branch 3 taken 1234 times.
|
168227 | if (sti->extract_extradata.inited && !sti->extract_extradata.bsf) |
| 2530 | 166993 | return 0; | |
| 2531 | |||
| 2532 | 1234 | ret = av_packet_ref(pkt_ref, pkt); | |
| 2533 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1234 times.
|
1234 | if (ret < 0) |
| 2534 | ✗ | return ret; | |
| 2535 | |||
| 2536 | 1234 | ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref); | |
| 2537 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1234 times.
|
1234 | if (ret < 0) { |
| 2538 | ✗ | av_packet_unref(pkt_ref); | |
| 2539 | ✗ | return ret; | |
| 2540 | } | ||
| 2541 | |||
| 2542 |
4/4✓ Branch 0 taken 2468 times.
✓ Branch 1 taken 394 times.
✓ Branch 2 taken 1628 times.
✓ Branch 3 taken 840 times.
|
2862 | while (ret >= 0 && !sti->avctx->extradata) { |
| 2543 | 1628 | ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref); | |
| 2544 |
2/2✓ Branch 0 taken 394 times.
✓ Branch 1 taken 1234 times.
|
1628 | if (ret < 0) { |
| 2545 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 394 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
394 | if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) |
| 2546 | ✗ | return ret; | |
| 2547 | 394 | continue; | |
| 2548 | } | ||
| 2549 | |||
| 2550 |
2/2✓ Branch 0 taken 1125 times.
✓ Branch 1 taken 394 times.
|
1519 | for (int i = 0; i < pkt_ref->side_data_elems; i++) { |
| 2551 | 1125 | AVPacketSideData *const side_data = &pkt_ref->side_data[i]; | |
| 2552 |
2/2✓ Branch 0 taken 840 times.
✓ Branch 1 taken 285 times.
|
1125 | if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) { |
| 2553 | 840 | sti->avctx->extradata = side_data->data; | |
| 2554 | 840 | sti->avctx->extradata_size = side_data->size; | |
| 2555 | 840 | side_data->data = NULL; | |
| 2556 | 840 | side_data->size = 0; | |
| 2557 | 840 | break; | |
| 2558 | } | ||
| 2559 | } | ||
| 2560 | 1234 | av_packet_unref(pkt_ref); | |
| 2561 | } | ||
| 2562 | |||
| 2563 | 1234 | return 0; | |
| 2564 | } | ||
| 2565 | |||
| 2566 | 9023 | static int parameters_from_context(AVFormatContext *ic, AVCodecParameters *par, | |
| 2567 | const AVCodecContext *avctx) | ||
| 2568 | { | ||
| 2569 | AVCodecParameters *par_tmp; | ||
| 2570 | int ret; | ||
| 2571 | |||
| 2572 | 9023 | par_tmp = avcodec_parameters_alloc(); | |
| 2573 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9023 times.
|
9023 | if (!par_tmp) |
| 2574 | ✗ | return AVERROR(ENOMEM); | |
| 2575 | |||
| 2576 | 9023 | ret = avcodec_parameters_copy(par_tmp, par); | |
| 2577 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9023 times.
|
9023 | if (ret < 0) |
| 2578 | ✗ | goto fail; | |
| 2579 | |||
| 2580 | 9023 | ret = avcodec_parameters_from_context(par, avctx); | |
| 2581 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9023 times.
|
9023 | if (ret < 0) |
| 2582 | ✗ | goto fail; | |
| 2583 | |||
| 2584 | /* Restore some values if they are signaled at the container level | ||
| 2585 | * given they may have been replaced by codec level values as read | ||
| 2586 | * internally by avformat_find_stream_info(). | ||
| 2587 | */ | ||
| 2588 |
2/2✓ Branch 0 taken 216 times.
✓ Branch 1 taken 8807 times.
|
9023 | if (par_tmp->color_range != AVCOL_RANGE_UNSPECIFIED) |
| 2589 | 216 | par->color_range = par_tmp->color_range; | |
| 2590 |
2/2✓ Branch 0 taken 101 times.
✓ Branch 1 taken 8922 times.
|
9023 | if (par_tmp->color_primaries != AVCOL_PRI_UNSPECIFIED) |
| 2591 | 101 | par->color_primaries = par_tmp->color_primaries; | |
| 2592 |
2/2✓ Branch 0 taken 116 times.
✓ Branch 1 taken 8907 times.
|
9023 | if (par_tmp->color_trc != AVCOL_TRC_UNSPECIFIED) |
| 2593 | 116 | par->color_trc = par_tmp->color_trc; | |
| 2594 |
2/2✓ Branch 0 taken 117 times.
✓ Branch 1 taken 8906 times.
|
9023 | if (par_tmp->color_space != AVCOL_SPC_UNSPECIFIED) |
| 2595 | 117 | par->color_space = par_tmp->color_space; | |
| 2596 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 8969 times.
|
9023 | if (par_tmp->chroma_location != AVCHROMA_LOC_UNSPECIFIED) |
| 2597 | 54 | par->chroma_location = par_tmp->chroma_location; | |
| 2598 | |||
| 2599 | 9023 | ret = 0; | |
| 2600 | 9023 | fail: | |
| 2601 | 9023 | avcodec_parameters_free(&par_tmp); | |
| 2602 | |||
| 2603 | 9023 | return ret; | |
| 2604 | } | ||
| 2605 | |||
| 2606 | 8136 | int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) | |
| 2607 | { | ||
| 2608 | 8136 | FFFormatContext *const si = ffformatcontext(ic); | |
| 2609 | 8136 | int count = 0, ret = 0, err; | |
| 2610 | int64_t read_size; | ||
| 2611 | 8136 | AVPacket *pkt1 = si->pkt; | |
| 2612 | 8136 | int64_t old_offset = avio_tell(ic->pb); | |
| 2613 | // new streams might appear, no options for those | ||
| 2614 | 8136 | int orig_nb_streams = ic->nb_streams; | |
| 2615 | int flush_codecs; | ||
| 2616 | 8136 | int64_t max_analyze_duration = ic->max_analyze_duration; | |
| 2617 | int64_t max_stream_analyze_duration; | ||
| 2618 | int64_t max_subtitle_analyze_duration; | ||
| 2619 | 8136 | int64_t probesize = ic->probesize; | |
| 2620 | 8136 | int eof_reached = 0; | |
| 2621 | |||
| 2622 | 8136 | flush_codecs = probesize > 0; | |
| 2623 | |||
| 2624 | 8136 | av_opt_set_int(ic, "skip_clear", 1, AV_OPT_SEARCH_CHILDREN); | |
| 2625 | |||
| 2626 | 8136 | max_stream_analyze_duration = max_analyze_duration; | |
| 2627 | 8136 | max_subtitle_analyze_duration = max_analyze_duration; | |
| 2628 |
2/2✓ Branch 0 taken 8134 times.
✓ Branch 1 taken 2 times.
|
8136 | if (!max_analyze_duration) { |
| 2629 | 8134 | max_stream_analyze_duration = | |
| 2630 | 8134 | max_analyze_duration = 5*AV_TIME_BASE; | |
| 2631 | 8134 | max_subtitle_analyze_duration = 30*AV_TIME_BASE; | |
| 2632 |
2/2✓ Branch 0 taken 39 times.
✓ Branch 1 taken 8095 times.
|
8134 | if (!strcmp(ic->iformat->name, "flv")) |
| 2633 | 39 | max_stream_analyze_duration = 90*AV_TIME_BASE; | |
| 2634 |
4/4✓ Branch 0 taken 8108 times.
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 8043 times.
|
8134 | if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts")) |
| 2635 | 91 | max_stream_analyze_duration = 7*AV_TIME_BASE; | |
| 2636 | } | ||
| 2637 | |||
| 2638 |
2/2✓ Branch 0 taken 4939 times.
✓ Branch 1 taken 3197 times.
|
8136 | if (ic->pb) { |
| 2639 | 4939 | FFIOContext *const ctx = ffiocontext(ic->pb); | |
| 2640 | 4939 | av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n", | |
| 2641 | avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, ic->nb_streams); | ||
| 2642 | } | ||
| 2643 | |||
| 2644 |
2/2✓ Branch 0 taken 8851 times.
✓ Branch 1 taken 8136 times.
|
16987 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 2645 | const AVCodec *codec; | ||
| 2646 | 8851 | AVDictionary *thread_opt = NULL; | |
| 2647 | 8851 | AVStream *const st = ic->streams[i]; | |
| 2648 | 8851 | FFStream *const sti = ffstream(st); | |
| 2649 | 8851 | AVCodecContext *const avctx = sti->avctx; | |
| 2650 | |||
| 2651 | /* check if the caller has overridden the codec id */ | ||
| 2652 | // only for the split stuff | ||
| 2653 |
4/6✓ Branch 0 taken 8851 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 8851 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8287 times.
✓ Branch 5 taken 564 times.
|
8851 | if (!sti->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && sti->request_probe <= 0) { |
| 2654 | 8287 | sti->parser = av_parser_init(st->codecpar->codec_id); | |
| 2655 |
2/2✓ Branch 0 taken 5871 times.
✓ Branch 1 taken 2416 times.
|
8287 | if (sti->parser) { |
| 2656 |
2/2✓ Branch 0 taken 813 times.
✓ Branch 1 taken 5058 times.
|
5871 | if (sti->need_parsing == AVSTREAM_PARSE_HEADERS) { |
| 2657 | 813 | sti->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES; | |
| 2658 |
2/2✓ Branch 0 taken 926 times.
✓ Branch 1 taken 4132 times.
|
5058 | } else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) { |
| 2659 | 926 | sti->parser->flags |= PARSER_FLAG_USE_CODEC_TS; | |
| 2660 | } | ||
| 2661 |
2/2✓ Branch 0 taken 682 times.
✓ Branch 1 taken 1734 times.
|
2416 | } else if (sti->need_parsing) { |
| 2662 | 682 | av_log(ic, AV_LOG_VERBOSE, "parser not found for codec " | |
| 2663 | "%s, packets or times may be invalid.\n", | ||
| 2664 | 682 | avcodec_get_name(st->codecpar->codec_id)); | |
| 2665 | } | ||
| 2666 | } | ||
| 2667 | |||
| 2668 | 8851 | ret = avcodec_parameters_to_context(avctx, st->codecpar); | |
| 2669 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8851 times.
|
8851 | if (ret < 0) |
| 2670 | ✗ | goto find_stream_info_err; | |
| 2671 |
2/2✓ Branch 0 taken 8287 times.
✓ Branch 1 taken 564 times.
|
8851 | if (sti->request_probe <= 0) |
| 2672 | 8287 | sti->avctx_inited = 1; | |
| 2673 | |||
| 2674 | 8851 | codec = find_probe_decoder(ic, st, st->codecpar->codec_id); | |
| 2675 | |||
| 2676 | /* Force thread count to 1 since the H.264 decoder will not extract | ||
| 2677 | * SPS and PPS to extradata during multi-threaded decoding. */ | ||
| 2678 |
2/2✓ Branch 0 taken 8555 times.
✓ Branch 1 taken 296 times.
|
8851 | av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0); |
| 2679 | /* Force lowres to 0. The decoder might reduce the video size by the | ||
| 2680 | * lowres factor, and we don't want that propagated to the stream's | ||
| 2681 | * codecpar */ | ||
| 2682 |
2/2✓ Branch 0 taken 8555 times.
✓ Branch 1 taken 296 times.
|
8851 | av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0); |
| 2683 | |||
| 2684 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8851 times.
|
8851 | if (ic->codec_whitelist) |
| 2685 | ✗ | av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0); | |
| 2686 | |||
| 2687 | // Try to just open decoders, in case this is enough to get parameters. | ||
| 2688 | // Also ensure that subtitle_header is properly set. | ||
| 2689 |
4/4✓ Branch 1 taken 7973 times.
✓ Branch 2 taken 878 times.
✓ Branch 3 taken 563 times.
✓ Branch 4 taken 7410 times.
|
8851 | if (!has_codec_parameters(st, NULL) && sti->request_probe <= 0 || |
| 2690 |
2/2✓ Branch 0 taken 90 times.
✓ Branch 1 taken 1351 times.
|
1441 | st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) { |
| 2691 |
3/4✓ Branch 0 taken 7458 times.
✓ Branch 1 taken 42 times.
✓ Branch 2 taken 7458 times.
✗ Branch 3 not taken.
|
7500 | if (codec && !avctx->codec) |
| 2692 |
4/4✓ Branch 0 taken 7168 times.
✓ Branch 1 taken 290 times.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 7452 times.
|
7458 | if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0) |
| 2693 | 6 | av_log(ic, AV_LOG_WARNING, | |
| 2694 | "Failed to open codec in %s\n", __func__); | ||
| 2695 | } | ||
| 2696 |
2/2✓ Branch 0 taken 296 times.
✓ Branch 1 taken 8555 times.
|
8851 | if (!options) |
| 2697 | 296 | av_dict_free(&thread_opt); | |
| 2698 | } | ||
| 2699 | |||
| 2700 | 8136 | read_size = 0; | |
| 2701 | 200835 | for (;;) { | |
| 2702 | const AVPacket *pkt; | ||
| 2703 | AVStream *st; | ||
| 2704 | FFStream *sti; | ||
| 2705 | AVCodecContext *avctx; | ||
| 2706 | int analyzed_all_streams; | ||
| 2707 | unsigned i; | ||
| 2708 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 208971 times.
|
208971 | if (ff_check_interrupt(&ic->interrupt_callback)) { |
| 2709 | ✗ | ret = AVERROR_EXIT; | |
| 2710 | ✗ | av_log(ic, AV_LOG_DEBUG, "interrupted\n"); | |
| 2711 | ✗ | break; | |
| 2712 | } | ||
| 2713 | |||
| 2714 | /* read_frame_internal() in a previous iteration of this loop may | ||
| 2715 | * have made changes to streams without returning a packet for them. | ||
| 2716 | * Handle that here. */ | ||
| 2717 | 208971 | ret = update_stream_avctx(ic); | |
| 2718 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 208971 times.
|
208971 | if (ret < 0) |
| 2719 | ✗ | goto unref_then_goto_end; | |
| 2720 | |||
| 2721 | /* check if one codec still needs to be handled */ | ||
| 2722 |
2/2✓ Branch 0 taken 218160 times.
✓ Branch 1 taken 115161 times.
|
333321 | for (i = 0; i < ic->nb_streams; i++) { |
| 2723 | 218160 | AVStream *const st = ic->streams[i]; | |
| 2724 | 218160 | FFStream *const sti = ffstream(st); | |
| 2725 | 218160 | int fps_analyze_framecount = 20; | |
| 2726 | int count; | ||
| 2727 | |||
| 2728 |
2/2✓ Branch 1 taken 7900 times.
✓ Branch 2 taken 210260 times.
|
218160 | if (!has_codec_parameters(st, NULL)) |
| 2729 | 7900 | break; | |
| 2730 | /* If the timebase is coarse (like the usual millisecond precision | ||
| 2731 | * of mkv), we need to analyze more frames to reliably arrive at | ||
| 2732 | * the correct fps. */ | ||
| 2733 |
2/2✓ Branch 1 taken 125226 times.
✓ Branch 2 taken 85034 times.
|
210260 | if (av_q2d(st->time_base) > 0.0005) |
| 2734 | 125226 | fps_analyze_framecount *= 2; | |
| 2735 |
2/2✓ Branch 1 taken 8695 times.
✓ Branch 2 taken 201565 times.
|
210260 | if (!tb_unreliable(ic, st)) |
| 2736 | 8695 | fps_analyze_framecount = 0; | |
| 2737 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 210260 times.
|
210260 | if (ic->fps_probe_size >= 0) |
| 2738 | ✗ | fps_analyze_framecount = ic->fps_probe_size; | |
| 2739 |
2/2✓ Branch 0 taken 52 times.
✓ Branch 1 taken 210208 times.
|
210260 | if (st->disposition & AV_DISPOSITION_ATTACHED_PIC) |
| 2740 | 52 | fps_analyze_framecount = 0; | |
| 2741 | /* variable fps and no guess at the real fps */ | ||
| 2742 |
2/2✓ Branch 0 taken 19848 times.
✓ Branch 1 taken 190412 times.
|
210260 | count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ? |
| 2743 | 19848 | sti->info->codec_info_duration_fields/2 : | |
| 2744 | 190412 | sti->info->duration_count; | |
| 2745 |
4/4✓ Branch 0 taken 105858 times.
✓ Branch 1 taken 104402 times.
✓ Branch 2 taken 423 times.
✓ Branch 3 taken 105435 times.
|
210260 | if (!(st->r_frame_rate.num && st->avg_frame_rate.num) && |
| 2746 |
2/2✓ Branch 0 taken 45062 times.
✓ Branch 1 taken 59763 times.
|
104825 | st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { |
| 2747 |
2/2✓ Branch 0 taken 26341 times.
✓ Branch 1 taken 18721 times.
|
45062 | if (count < fps_analyze_framecount) |
| 2748 | 26341 | break; | |
| 2749 | } | ||
| 2750 | // Look at the first 3 frames if there is evidence of frame delay | ||
| 2751 | // but the decoder delay is not set. | ||
| 2752 |
6/6✓ Branch 0 taken 3350 times.
✓ Branch 1 taken 180569 times.
✓ Branch 2 taken 167 times.
✓ Branch 3 taken 3183 times.
✓ Branch 4 taken 8 times.
✓ Branch 5 taken 159 times.
|
183919 | if (sti->info->frame_delay_evidence && count < 2 && sti->avctx->has_b_frames == 0) |
| 2753 | 8 | break; | |
| 2754 |
2/2✓ Branch 0 taken 162433 times.
✓ Branch 1 taken 21478 times.
|
183911 | if (!sti->avctx->extradata && |
| 2755 |
6/6✓ Branch 0 taken 160516 times.
✓ Branch 1 taken 1917 times.
✓ Branch 2 taken 110 times.
✓ Branch 3 taken 160406 times.
✓ Branch 4 taken 110 times.
✓ Branch 5 taken 1917 times.
|
164460 | (!sti->extract_extradata.inited || sti->extract_extradata.bsf) && |
| 2756 | 2027 | extract_extradata_check(st)) | |
| 2757 | 110 | break; | |
| 2758 |
2/2✓ Branch 0 taken 62829 times.
✓ Branch 1 taken 120972 times.
|
183801 | if (sti->first_dts == AV_NOPTS_VALUE && |
| 2759 |
6/6✓ Branch 0 taken 9717 times.
✓ Branch 1 taken 53112 times.
✓ Branch 2 taken 9533 times.
✓ Branch 3 taken 184 times.
✓ Branch 4 taken 60309 times.
✓ Branch 5 taken 2336 times.
|
125474 | (!(ic->iformat->flags & AVFMT_NOTIMESTAMPS) || sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) && |
| 2760 |
2/2✓ Branch 0 taken 62593 times.
✓ Branch 1 taken 52 times.
|
62645 | sti->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) && |
| 2761 |
2/2✓ Branch 0 taken 44181 times.
✓ Branch 1 taken 16128 times.
|
60309 | (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO || |
| 2762 |
2/2✓ Branch 0 taken 858 times.
✓ Branch 1 taken 43323 times.
|
44181 | st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)) |
| 2763 | break; | ||
| 2764 | } | ||
| 2765 | 208971 | analyzed_all_streams = 0; | |
| 2766 |
4/4✓ Branch 0 taken 115161 times.
✓ Branch 1 taken 93810 times.
✓ Branch 2 taken 115121 times.
✓ Branch 3 taken 40 times.
|
208971 | if (i == ic->nb_streams && !si->missing_streams) { |
| 2767 | 115121 | analyzed_all_streams = 1; | |
| 2768 | /* NOTE: If the format has no header, then we need to read some | ||
| 2769 | * packets to get most of the streams, so we cannot stop here. */ | ||
| 2770 |
2/2✓ Branch 0 taken 3586 times.
✓ Branch 1 taken 111535 times.
|
115121 | if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) { |
| 2771 | /* If we found the info for all the codecs, we can stop. */ | ||
| 2772 | 3586 | ret = count; | |
| 2773 | 3586 | av_log(ic, AV_LOG_DEBUG, "All info found\n"); | |
| 2774 | 3586 | flush_codecs = 0; | |
| 2775 | 3586 | break; | |
| 2776 | } | ||
| 2777 | } | ||
| 2778 | /* We did not get all the codec info, but we read too much data. */ | ||
| 2779 |
2/2✓ Branch 0 taken 3093 times.
✓ Branch 1 taken 202292 times.
|
205385 | if (read_size >= probesize) { |
| 2780 | 3093 | ret = count; | |
| 2781 | 3093 | av_log(ic, AV_LOG_DEBUG, | |
| 2782 | "Probe buffer size limit of %"PRId64" bytes reached\n", probesize); | ||
| 2783 |
2/2✓ Branch 0 taken 3107 times.
✓ Branch 1 taken 3093 times.
|
6200 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 2784 | 3107 | AVStream *const st = ic->streams[i]; | |
| 2785 | 3107 | FFStream *const sti = ffstream(st); | |
| 2786 |
2/2✓ Branch 0 taken 57 times.
✓ Branch 1 taken 3050 times.
|
3107 | if (!st->r_frame_rate.num && |
| 2787 |
2/2✓ Branch 0 taken 17 times.
✓ Branch 1 taken 40 times.
|
57 | sti->info->duration_count <= 1 && |
| 2788 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16 times.
|
17 | st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && |
| 2789 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | strcmp(ic->iformat->name, "image2")) |
| 2790 | 1 | av_log(ic, AV_LOG_WARNING, | |
| 2791 | "Stream #%d: not enough frames to estimate rate; " | ||
| 2792 | "consider increasing probesize\n", i); | ||
| 2793 | } | ||
| 2794 | 3093 | break; | |
| 2795 | } | ||
| 2796 | |||
| 2797 | /* NOTE: A new stream can be added there if no header in file | ||
| 2798 | * (AVFMTCTX_NOHEADER). */ | ||
| 2799 | 202292 | ret = read_frame_internal(ic, pkt1); | |
| 2800 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 202292 times.
|
202292 | if (ret == AVERROR(EAGAIN)) |
| 2801 | ✗ | continue; | |
| 2802 | |||
| 2803 |
2/2✓ Branch 0 taken 1362 times.
✓ Branch 1 taken 200930 times.
|
202292 | if (ret < 0) { |
| 2804 | /* EOF or error*/ | ||
| 2805 | 1362 | eof_reached = 1; | |
| 2806 | 1362 | break; | |
| 2807 | } | ||
| 2808 | |||
| 2809 |
1/2✓ Branch 0 taken 200930 times.
✗ Branch 1 not taken.
|
200930 | if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) { |
| 2810 | 200930 | ret = ff_packet_list_put(&si->packet_buffer, | |
| 2811 | pkt1, NULL, 0); | ||
| 2812 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200930 times.
|
200930 | if (ret < 0) |
| 2813 | ✗ | goto unref_then_goto_end; | |
| 2814 | |||
| 2815 | 200930 | pkt = &si->packet_buffer.tail->pkt; | |
| 2816 | } else { | ||
| 2817 | ✗ | pkt = pkt1; | |
| 2818 | } | ||
| 2819 | |||
| 2820 | 200930 | st = ic->streams[pkt->stream_index]; | |
| 2821 | 200930 | sti = ffstream(st); | |
| 2822 |
2/2✓ Branch 0 taken 200865 times.
✓ Branch 1 taken 65 times.
|
200930 | if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) |
| 2823 | 200865 | read_size += pkt->size; | |
| 2824 | |||
| 2825 | 200930 | avctx = sti->avctx; | |
| 2826 |
2/2✓ Branch 0 taken 736 times.
✓ Branch 1 taken 200194 times.
|
200930 | if (!sti->avctx_inited) { |
| 2827 | 736 | ret = avcodec_parameters_to_context(avctx, st->codecpar); | |
| 2828 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 736 times.
|
736 | if (ret < 0) |
| 2829 | ✗ | goto unref_then_goto_end; | |
| 2830 | 736 | sti->avctx_inited = 1; | |
| 2831 | } | ||
| 2832 | |||
| 2833 |
4/4✓ Branch 0 taken 183949 times.
✓ Branch 1 taken 16981 times.
✓ Branch 2 taken 170837 times.
✓ Branch 3 taken 13112 times.
|
200930 | if (pkt->dts != AV_NOPTS_VALUE && sti->codec_info_nb_frames > 1) { |
| 2834 | /* check for non-increasing dts */ | ||
| 2835 |
2/2✓ Branch 0 taken 165685 times.
✓ Branch 1 taken 5152 times.
|
170837 | if (sti->info->fps_last_dts != AV_NOPTS_VALUE && |
| 2836 |
2/2✓ Branch 0 taken 23 times.
✓ Branch 1 taken 165662 times.
|
165685 | sti->info->fps_last_dts >= pkt->dts) { |
| 2837 | 23 | av_log(ic, AV_LOG_DEBUG, | |
| 2838 | "Non-increasing DTS in stream %d: packet %d with DTS " | ||
| 2839 | "%"PRId64", packet %d with DTS %"PRId64"\n", | ||
| 2840 | 23 | st->index, sti->info->fps_last_dts_idx, | |
| 2841 | 23 | sti->info->fps_last_dts, sti->codec_info_nb_frames, | |
| 2842 | 23 | pkt->dts); | |
| 2843 | 23 | sti->info->fps_first_dts = | |
| 2844 | 23 | sti->info->fps_last_dts = AV_NOPTS_VALUE; | |
| 2845 | } | ||
| 2846 | /* Check for a discontinuity in dts. If the difference in dts | ||
| 2847 | * is more than 1000 times the average packet duration in the | ||
| 2848 | * sequence, we treat it as a discontinuity. */ | ||
| 2849 |
2/2✓ Branch 0 taken 165662 times.
✓ Branch 1 taken 5175 times.
|
170837 | if (sti->info->fps_last_dts != AV_NOPTS_VALUE && |
| 2850 |
2/2✓ Branch 0 taken 160544 times.
✓ Branch 1 taken 5118 times.
|
165662 | sti->info->fps_last_dts_idx > sti->info->fps_first_dts_idx && |
| 2851 | 160544 | (pkt->dts - (uint64_t)sti->info->fps_last_dts) / 1000 > | |
| 2852 | 160544 | (sti->info->fps_last_dts - (uint64_t)sti->info->fps_first_dts) / | |
| 2853 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 160544 times.
|
160544 | (sti->info->fps_last_dts_idx - sti->info->fps_first_dts_idx)) { |
| 2854 | ✗ | av_log(ic, AV_LOG_WARNING, | |
| 2855 | "DTS discontinuity in stream %d: packet %d with DTS " | ||
| 2856 | "%"PRId64", packet %d with DTS %"PRId64"\n", | ||
| 2857 | ✗ | st->index, sti->info->fps_last_dts_idx, | |
| 2858 | ✗ | sti->info->fps_last_dts, sti->codec_info_nb_frames, | |
| 2859 | ✗ | pkt->dts); | |
| 2860 | ✗ | sti->info->fps_first_dts = | |
| 2861 | ✗ | sti->info->fps_last_dts = AV_NOPTS_VALUE; | |
| 2862 | } | ||
| 2863 | |||
| 2864 | /* update stored dts values */ | ||
| 2865 |
2/2✓ Branch 0 taken 5175 times.
✓ Branch 1 taken 165662 times.
|
170837 | if (sti->info->fps_first_dts == AV_NOPTS_VALUE) { |
| 2866 | 5175 | sti->info->fps_first_dts = pkt->dts; | |
| 2867 | 5175 | sti->info->fps_first_dts_idx = sti->codec_info_nb_frames; | |
| 2868 | } | ||
| 2869 | 170837 | sti->info->fps_last_dts = pkt->dts; | |
| 2870 | 170837 | sti->info->fps_last_dts_idx = sti->codec_info_nb_frames; | |
| 2871 | } | ||
| 2872 |
2/2✓ Branch 0 taken 186554 times.
✓ Branch 1 taken 14376 times.
|
200930 | if (sti->codec_info_nb_frames > 1) { |
| 2873 | 186554 | int64_t t = 0; | |
| 2874 | int64_t limit; | ||
| 2875 | |||
| 2876 |
1/2✓ Branch 0 taken 186554 times.
✗ Branch 1 not taken.
|
186554 | if (st->time_base.den > 0) |
| 2877 | 186554 | t = av_rescale_q(sti->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q); | |
| 2878 |
2/2✓ Branch 0 taken 117115 times.
✓ Branch 1 taken 69439 times.
|
186554 | if (st->avg_frame_rate.num > 0) |
| 2879 |
2/2✓ Branch 1 taken 116588 times.
✓ Branch 2 taken 527 times.
|
117115 | t = FFMAX(t, av_rescale_q(sti->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q)); |
| 2880 | |||
| 2881 |
2/2✓ Branch 0 taken 4619 times.
✓ Branch 1 taken 181935 times.
|
186554 | if ( t == 0 |
| 2882 |
2/2✓ Branch 0 taken 564 times.
✓ Branch 1 taken 4055 times.
|
4619 | && sti->codec_info_nb_frames > 30 |
| 2883 |
2/2✓ Branch 0 taken 497 times.
✓ Branch 1 taken 67 times.
|
564 | && sti->info->fps_first_dts != AV_NOPTS_VALUE |
| 2884 |
1/2✓ Branch 0 taken 497 times.
✗ Branch 1 not taken.
|
497 | && sti->info->fps_last_dts != AV_NOPTS_VALUE) { |
| 2885 | 497 | int64_t dur = av_sat_sub64(sti->info->fps_last_dts, sti->info->fps_first_dts); | |
| 2886 |
1/2✓ Branch 0 taken 497 times.
✗ Branch 1 not taken.
|
497 | t = FFMAX(t, av_rescale_q(dur, st->time_base, AV_TIME_BASE_Q)); |
| 2887 | } | ||
| 2888 | |||
| 2889 |
2/2✓ Branch 0 taken 105052 times.
✓ Branch 1 taken 81502 times.
|
186554 | if (analyzed_all_streams) limit = max_analyze_duration; |
| 2890 |
2/2✓ Branch 0 taken 91 times.
✓ Branch 1 taken 81411 times.
|
81502 | else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration; |
| 2891 | 81411 | else limit = max_stream_analyze_duration; | |
| 2892 | |||
| 2893 |
2/2✓ Branch 0 taken 95 times.
✓ Branch 1 taken 186459 times.
|
186554 | if (t >= limit) { |
| 2894 | 95 | av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n", | |
| 2895 | limit, | ||
| 2896 | 95 | t, pkt->stream_index); | |
| 2897 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
|
95 | if (ic->flags & AVFMT_FLAG_NOBUFFER) |
| 2898 | ✗ | av_packet_unref(pkt1); | |
| 2899 | 95 | break; | |
| 2900 | } | ||
| 2901 |
3/4✓ Branch 0 taken 182432 times.
✓ Branch 1 taken 4027 times.
✓ Branch 2 taken 182432 times.
✗ Branch 3 not taken.
|
186459 | if (pkt->duration > 0 && pkt->duration < INT64_MAX - sti->info->codec_info_duration) { |
| 2902 |
4/4✓ Branch 0 taken 182392 times.
✓ Branch 1 taken 40 times.
✓ Branch 2 taken 14764 times.
✓ Branch 3 taken 167628 times.
|
182432 | const int fields = sti->codec_desc && (sti->codec_desc->props & AV_CODEC_PROP_FIELDS); |
| 2903 |
1/8✗ Branch 0 not taken.
✓ Branch 1 taken 182432 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
182432 | if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time |
| 2904 | ✗ | && (uint64_t)pkt->pts - st->start_time < INT64_MAX | |
| 2905 | ) { | ||
| 2906 | ✗ | sti->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, sti->info->codec_info_duration + pkt->duration); | |
| 2907 | } else | ||
| 2908 | 182432 | sti->info->codec_info_duration += pkt->duration; | |
| 2909 |
4/4✓ Branch 0 taken 38996 times.
✓ Branch 1 taken 96127 times.
✓ Branch 2 taken 14131 times.
✓ Branch 3 taken 24865 times.
|
317555 | sti->info->codec_info_duration_fields += sti->parser && sti->need_parsing && fields |
| 2910 |
2/2✓ Branch 0 taken 135123 times.
✓ Branch 1 taken 47309 times.
|
317555 | ? sti->parser->repeat_pict + 1 : 2; |
| 2911 | } | ||
| 2912 | } | ||
| 2913 |
2/2✓ Branch 0 taken 137128 times.
✓ Branch 1 taken 63707 times.
|
200835 | if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { |
| 2914 | #if FF_API_R_FRAME_RATE | ||
| 2915 | 137128 | ff_rfps_add_frame(ic, st, pkt->dts); | |
| 2916 | #endif | ||
| 2917 |
6/6✓ Branch 0 taken 5022 times.
✓ Branch 1 taken 132106 times.
✓ Branch 2 taken 4730 times.
✓ Branch 3 taken 292 times.
✓ Branch 4 taken 2706 times.
✓ Branch 5 taken 2024 times.
|
137128 | if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE) |
| 2918 | 2706 | sti->info->frame_delay_evidence = 1; | |
| 2919 | } | ||
| 2920 |
2/2✓ Branch 0 taken 168086 times.
✓ Branch 1 taken 32749 times.
|
200835 | if (!sti->avctx->extradata) { |
| 2921 | 168086 | ret = extract_extradata(si, st, pkt); | |
| 2922 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 168086 times.
|
168086 | if (ret < 0) |
| 2923 | ✗ | goto unref_then_goto_end; | |
| 2924 | } | ||
| 2925 | |||
| 2926 | /* If still no information, we try to open the codec and to | ||
| 2927 | * decompress the frame. We try to avoid that in most cases as | ||
| 2928 | * it takes longer and uses more memory. For MPEG-4, we need to | ||
| 2929 | * decompress for QuickTime. | ||
| 2930 | * | ||
| 2931 | * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at | ||
| 2932 | * least one frame of codec data, this makes sure the codec initializes | ||
| 2933 | * the channel configuration and does not only trust the values from | ||
| 2934 | * the container. */ | ||
| 2935 |
2/2✓ Branch 0 taken 183139 times.
✓ Branch 1 taken 17696 times.
|
383974 | try_decode_frame(ic, st, pkt, |
| 2936 |
2/2✓ Branch 0 taken 82230 times.
✓ Branch 1 taken 100909 times.
|
183139 | (options && i < orig_nb_streams) ? &options[i] : NULL); |
| 2937 | |||
| 2938 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200835 times.
|
200835 | if (ic->flags & AVFMT_FLAG_NOBUFFER) |
| 2939 | ✗ | av_packet_unref(pkt1); | |
| 2940 | |||
| 2941 | 200835 | sti->codec_info_nb_frames++; | |
| 2942 | 200835 | count++; | |
| 2943 | } | ||
| 2944 | |||
| 2945 |
2/2✓ Branch 0 taken 1362 times.
✓ Branch 1 taken 6774 times.
|
8136 | if (eof_reached) { |
| 2946 |
2/2✓ Branch 0 taken 1694 times.
✓ Branch 1 taken 1362 times.
|
3056 | for (unsigned stream_index = 0; stream_index < ic->nb_streams; stream_index++) { |
| 2947 | 1694 | AVStream *const st = ic->streams[stream_index]; | |
| 2948 | 1694 | AVCodecContext *const avctx = ffstream(st)->avctx; | |
| 2949 |
2/2✓ Branch 1 taken 39 times.
✓ Branch 2 taken 1655 times.
|
1694 | if (!has_codec_parameters(st, NULL)) { |
| 2950 | 39 | const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id); | |
| 2951 |
4/4✓ Branch 0 taken 24 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 14 times.
|
39 | if (codec && !avctx->codec) { |
| 2952 | 10 | AVDictionary *opts = NULL; | |
| 2953 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | if (ic->codec_whitelist) |
| 2954 | ✗ | av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0); | |
| 2955 |
4/6✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 10 times.
|
10 | if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0) |
| 2956 | ✗ | av_log(ic, AV_LOG_WARNING, | |
| 2957 | "Failed to open codec in %s\n", __func__); | ||
| 2958 | 10 | av_dict_free(&opts); | |
| 2959 | } | ||
| 2960 | } | ||
| 2961 | |||
| 2962 | // EOF already reached while reading the stream above. | ||
| 2963 | // So continue with reoordering DTS with whatever delay we have. | ||
| 2964 |
4/4✓ Branch 0 taken 1672 times.
✓ Branch 1 taken 22 times.
✓ Branch 3 taken 19 times.
✓ Branch 4 taken 1653 times.
|
1694 | if (si->packet_buffer.head && !has_decode_delay_been_guessed(st)) { |
| 2965 | 19 | update_dts_from_pts(ic, stream_index, si->packet_buffer.head); | |
| 2966 | } | ||
| 2967 | } | ||
| 2968 | } | ||
| 2969 | |||
| 2970 |
2/2✓ Branch 0 taken 4550 times.
✓ Branch 1 taken 3586 times.
|
8136 | if (flush_codecs) { |
| 2971 | 4550 | AVPacket *empty_pkt = si->pkt; | |
| 2972 | 4550 | int err = 0; | |
| 2973 | 4550 | av_packet_unref(empty_pkt); | |
| 2974 | |||
| 2975 |
2/2✓ Branch 0 taken 4935 times.
✓ Branch 1 taken 4550 times.
|
9485 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 2976 | 4935 | AVStream *const st = ic->streams[i]; | |
| 2977 | 4935 | FFStream *const sti = ffstream(st); | |
| 2978 | |||
| 2979 | /* flush the decoders */ | ||
| 2980 |
2/2✓ Branch 0 taken 4843 times.
✓ Branch 1 taken 92 times.
|
4935 | if (sti->info->found_decoder == 1) { |
| 2981 |
2/2✓ Branch 0 taken 4525 times.
✓ Branch 1 taken 318 times.
|
9368 | err = try_decode_frame(ic, st, empty_pkt, |
| 2982 |
2/2✓ Branch 0 taken 4509 times.
✓ Branch 1 taken 16 times.
|
4525 | (options && i < orig_nb_streams) |
| 2983 | 4509 | ? &options[i] : NULL); | |
| 2984 | |||
| 2985 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4843 times.
|
4843 | if (err < 0) { |
| 2986 | ✗ | av_log(ic, AV_LOG_INFO, | |
| 2987 | "decoding for stream %d failed\n", st->index); | ||
| 2988 | } | ||
| 2989 | } | ||
| 2990 | } | ||
| 2991 | } | ||
| 2992 | |||
| 2993 | 8136 | ff_rfps_calculate(ic); | |
| 2994 | |||
| 2995 |
2/2✓ Branch 0 taken 9038 times.
✓ Branch 1 taken 8136 times.
|
17174 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 2996 | 9038 | AVStream *const st = ic->streams[i]; | |
| 2997 | 9038 | FFStream *const sti = ffstream(st); | |
| 2998 | 9038 | AVCodecContext *const avctx = sti->avctx; | |
| 2999 | |||
| 3000 |
2/2✓ Branch 0 taken 6571 times.
✓ Branch 1 taken 2467 times.
|
9038 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
| 3001 |
6/6✓ Branch 0 taken 645 times.
✓ Branch 1 taken 5926 times.
✓ Branch 2 taken 596 times.
✓ Branch 3 taken 49 times.
✓ Branch 4 taken 580 times.
✓ Branch 5 taken 16 times.
|
6571 | if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) { |
| 3002 | 580 | uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt); | |
| 3003 |
2/2✓ Branch 1 taken 573 times.
✓ Branch 2 taken 7 times.
|
580 | if (avpriv_pix_fmt_find(PIX_FMT_LIST_RAW, tag) == avctx->pix_fmt) |
| 3004 | 573 | avctx->codec_tag= tag; | |
| 3005 | } | ||
| 3006 | |||
| 3007 | /* estimate average framerate if not set by demuxer */ | ||
| 3008 |
2/2✓ Branch 0 taken 4188 times.
✓ Branch 1 taken 2383 times.
|
6571 | if (sti->info->codec_info_duration_fields && |
| 3009 |
2/2✓ Branch 0 taken 311 times.
✓ Branch 1 taken 3877 times.
|
4188 | !st->avg_frame_rate.num && |
| 3010 |
1/2✓ Branch 0 taken 311 times.
✗ Branch 1 not taken.
|
311 | sti->info->codec_info_duration) { |
| 3011 | 311 | int best_fps = 0; | |
| 3012 | 311 | double best_error = 0.01; | |
| 3013 | 311 | AVRational codec_frame_rate = avctx->framerate; | |
| 3014 | |||
| 3015 |
1/2✓ Branch 0 taken 311 times.
✗ Branch 1 not taken.
|
311 | if (sti->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2|| |
| 3016 |
1/2✓ Branch 0 taken 311 times.
✗ Branch 1 not taken.
|
311 | sti->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den || |
| 3017 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 311 times.
|
311 | sti->info->codec_info_duration < 0) |
| 3018 | ✗ | continue; | |
| 3019 | 311 | av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den, | |
| 3020 | 311 | sti->info->codec_info_duration_fields * (int64_t) st->time_base.den, | |
| 3021 | 311 | sti->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000); | |
| 3022 | |||
| 3023 | /* Round guessed framerate to a "standard" framerate if it's | ||
| 3024 | * within 1% of the original estimate. */ | ||
| 3025 |
2/2✓ Branch 0 taken 124089 times.
✓ Branch 1 taken 311 times.
|
124400 | for (int j = 0; j < MAX_STD_TIMEBASES; j++) { |
| 3026 | 124089 | AVRational std_fps = { get_std_framerate(j), 12 * 1001 }; | |
| 3027 | 124089 | double error = fabs(av_q2d(st->avg_frame_rate) / | |
| 3028 | 124089 | av_q2d(std_fps) - 1); | |
| 3029 | |||
| 3030 |
2/2✓ Branch 0 taken 862 times.
✓ Branch 1 taken 123227 times.
|
124089 | if (error < best_error) { |
| 3031 | 862 | best_error = error; | |
| 3032 | 862 | best_fps = std_fps.num; | |
| 3033 | } | ||
| 3034 | |||
| 3035 |
2/2✓ Branch 1 taken 18753 times.
✓ Branch 2 taken 105336 times.
|
124089 | if ((ffifmt(ic->iformat)->flags_internal & FF_INFMT_FLAG_PREFER_CODEC_FRAMERATE) && |
| 3036 |
2/4✓ Branch 0 taken 18753 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 18753 times.
✗ Branch 3 not taken.
|
18753 | codec_frame_rate.num > 0 && codec_frame_rate.den > 0) { |
| 3037 | 18753 | error = fabs(av_q2d(codec_frame_rate) / | |
| 3038 | 18753 | av_q2d(std_fps) - 1); | |
| 3039 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 18743 times.
|
18753 | if (error < best_error) { |
| 3040 | 10 | best_error = error; | |
| 3041 | 10 | best_fps = std_fps.num; | |
| 3042 | } | ||
| 3043 | } | ||
| 3044 | } | ||
| 3045 |
2/2✓ Branch 0 taken 308 times.
✓ Branch 1 taken 3 times.
|
311 | if (best_fps) |
| 3046 | 308 | av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den, | |
| 3047 | best_fps, 12 * 1001, INT_MAX); | ||
| 3048 | } | ||
| 3049 |
2/2✓ Branch 0 taken 1920 times.
✓ Branch 1 taken 4651 times.
|
6571 | if (!st->r_frame_rate.num) { |
| 3050 | 1920 | const AVCodecDescriptor *desc = sti->codec_desc; | |
| 3051 |
3/4✓ Branch 0 taken 1920 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 247 times.
✓ Branch 3 taken 1673 times.
|
1920 | AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 }; |
| 3052 | 1920 | AVRational fr = av_mul_q(avctx->framerate, mul); | |
| 3053 | |||
| 3054 |
5/6✓ Branch 0 taken 197 times.
✓ Branch 1 taken 1723 times.
✓ Branch 2 taken 197 times.
✗ Branch 3 not taken.
✓ Branch 6 taken 183 times.
✓ Branch 7 taken 14 times.
|
1920 | if (fr.num && fr.den && av_cmp_q(st->time_base, av_inv_q(fr)) <= 0) { |
| 3055 | 183 | st->r_frame_rate = fr; | |
| 3056 | } else { | ||
| 3057 | 1737 | st->r_frame_rate.num = st->time_base.den; | |
| 3058 | 1737 | st->r_frame_rate.den = st->time_base.num; | |
| 3059 | } | ||
| 3060 | } | ||
| 3061 | 6571 | st->codecpar->framerate = avctx->framerate; | |
| 3062 |
3/4✓ Branch 0 taken 116 times.
✓ Branch 1 taken 6455 times.
✓ Branch 2 taken 116 times.
✗ Branch 3 not taken.
|
6571 | if (sti->display_aspect_ratio.num && sti->display_aspect_ratio.den) { |
| 3063 | 116 | AVRational hw_ratio = { avctx->height, avctx->width }; | |
| 3064 | 116 | st->sample_aspect_ratio = av_mul_q(sti->display_aspect_ratio, | |
| 3065 | hw_ratio); | ||
| 3066 | } | ||
| 3067 |
2/2✓ Branch 0 taken 2271 times.
✓ Branch 1 taken 196 times.
|
2467 | } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) { |
| 3068 |
2/2✓ Branch 0 taken 830 times.
✓ Branch 1 taken 1441 times.
|
2271 | if (!avctx->bits_per_coded_sample) |
| 3069 | 830 | avctx->bits_per_coded_sample = | |
| 3070 | 830 | av_get_bits_per_sample(avctx->codec_id); | |
| 3071 | // set stream disposition based on audio service type | ||
| 3072 |
1/6✗ Branch 0 not taken.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2271 times.
|
2271 | switch (avctx->audio_service_type) { |
| 3073 | ✗ | case AV_AUDIO_SERVICE_TYPE_EFFECTS: | |
| 3074 | ✗ | st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; | |
| 3075 | ✗ | break; | |
| 3076 | ✗ | case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED: | |
| 3077 | ✗ | st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; | |
| 3078 | ✗ | break; | |
| 3079 | ✗ | case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED: | |
| 3080 | ✗ | st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; | |
| 3081 | ✗ | break; | |
| 3082 | ✗ | case AV_AUDIO_SERVICE_TYPE_COMMENTARY: | |
| 3083 | ✗ | st->disposition = AV_DISPOSITION_COMMENT; | |
| 3084 | ✗ | break; | |
| 3085 | ✗ | case AV_AUDIO_SERVICE_TYPE_KARAOKE: | |
| 3086 | ✗ | st->disposition = AV_DISPOSITION_KARAOKE; | |
| 3087 | ✗ | break; | |
| 3088 | } | ||
| 3089 | } | ||
| 3090 | } | ||
| 3091 | |||
| 3092 |
1/2✓ Branch 0 taken 8136 times.
✗ Branch 1 not taken.
|
8136 | if (probesize) |
| 3093 | 8136 | estimate_timings(ic, old_offset); | |
| 3094 | |||
| 3095 | 8136 | av_opt_set_int(ic, "skip_clear", 0, AV_OPT_SEARCH_CHILDREN); | |
| 3096 | |||
| 3097 |
4/4✓ Branch 0 taken 6774 times.
✓ Branch 1 taken 1362 times.
✓ Branch 2 taken 6773 times.
✓ Branch 3 taken 1 times.
|
8136 | if (ret >= 0 && ic->nb_streams) |
| 3098 | /* We could not have all the codec parameters before EOF. */ | ||
| 3099 | 6773 | ret = -1; | |
| 3100 |
2/2✓ Branch 0 taken 9038 times.
✓ Branch 1 taken 8136 times.
|
17174 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 3101 | 9038 | AVStream *const st = ic->streams[i]; | |
| 3102 | 9038 | FFStream *const sti = ffstream(st); | |
| 3103 | const char *errmsg; | ||
| 3104 | |||
| 3105 | /* if no packet was ever seen, update context now for has_codec_parameters */ | ||
| 3106 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 9023 times.
|
9038 | if (!sti->avctx_inited) { |
| 3107 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 5 times.
|
15 | if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && |
| 3108 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | st->codecpar->format == AV_SAMPLE_FMT_NONE) |
| 3109 | 10 | st->codecpar->format = sti->avctx->sample_fmt; | |
| 3110 | 15 | ret = avcodec_parameters_to_context(sti->avctx, st->codecpar); | |
| 3111 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
|
15 | if (ret < 0) |
| 3112 | ✗ | goto find_stream_info_err; | |
| 3113 | } | ||
| 3114 |
2/2✓ Branch 1 taken 38 times.
✓ Branch 2 taken 9000 times.
|
9038 | if (!has_codec_parameters(st, &errmsg)) { |
| 3115 | char buf[256]; | ||
| 3116 | 38 | avcodec_string(buf, sizeof(buf), sti->avctx, 0); | |
| 3117 | 38 | av_log(ic, AV_LOG_WARNING, | |
| 3118 | "Could not find codec parameters for stream %d (%s): %s\n" | ||
| 3119 | "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n", | ||
| 3120 | i, buf, errmsg, ic->max_analyze_duration, ic->probesize); | ||
| 3121 | } else { | ||
| 3122 | 9000 | ret = 0; | |
| 3123 | } | ||
| 3124 | } | ||
| 3125 | |||
| 3126 | 8136 | err = compute_chapters_end(ic); | |
| 3127 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8136 times.
|
8136 | if (err < 0) { |
| 3128 | ✗ | ret = err; | |
| 3129 | ✗ | goto find_stream_info_err; | |
| 3130 | } | ||
| 3131 | |||
| 3132 | /* update the stream parameters from the internal codec contexts */ | ||
| 3133 |
2/2✓ Branch 0 taken 9038 times.
✓ Branch 1 taken 8136 times.
|
17174 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 3134 | 9038 | AVStream *const st = ic->streams[i]; | |
| 3135 | 9038 | FFStream *const sti = ffstream(st); | |
| 3136 | |||
| 3137 |
2/2✓ Branch 0 taken 9023 times.
✓ Branch 1 taken 15 times.
|
9038 | if (sti->avctx_inited) { |
| 3138 | 9023 | ret = parameters_from_context(ic, st->codecpar, sti->avctx); | |
| 3139 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9023 times.
|
9023 | if (ret < 0) |
| 3140 | ✗ | goto find_stream_info_err; | |
| 3141 | |||
| 3142 |
3/4✓ Branch 0 taken 8812 times.
✓ Branch 1 taken 211 times.
✓ Branch 2 taken 8812 times.
✗ Branch 3 not taken.
|
9023 | if (sti->avctx->rc_buffer_size > 0 || sti->avctx->rc_max_rate > 0 || |
| 3143 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8812 times.
|
8812 | sti->avctx->rc_min_rate) { |
| 3144 | size_t cpb_size; | ||
| 3145 | 211 | AVCPBProperties *props = av_cpb_properties_alloc(&cpb_size); | |
| 3146 |
1/2✓ Branch 0 taken 211 times.
✗ Branch 1 not taken.
|
211 | if (props) { |
| 3147 |
1/2✓ Branch 0 taken 211 times.
✗ Branch 1 not taken.
|
211 | if (sti->avctx->rc_buffer_size > 0) |
| 3148 | 211 | props->buffer_size = sti->avctx->rc_buffer_size; | |
| 3149 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 211 times.
|
211 | if (sti->avctx->rc_min_rate > 0) |
| 3150 | ✗ | props->min_bitrate = sti->avctx->rc_min_rate; | |
| 3151 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 132 times.
|
211 | if (sti->avctx->rc_max_rate > 0) |
| 3152 | 79 | props->max_bitrate = sti->avctx->rc_max_rate; | |
| 3153 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 211 times.
|
211 | if (!av_packet_side_data_add(&st->codecpar->coded_side_data, |
| 3154 | 211 | &st->codecpar->nb_coded_side_data, | |
| 3155 | AV_PKT_DATA_CPB_PROPERTIES, | ||
| 3156 | (uint8_t *)props, cpb_size, 0)) | ||
| 3157 | ✗ | av_free(props); | |
| 3158 | } | ||
| 3159 | } | ||
| 3160 | } | ||
| 3161 | |||
| 3162 | 9038 | sti->avctx_inited = 0; | |
| 3163 | } | ||
| 3164 | |||
| 3165 | /* update the stream group parameters from the stream contexts if needed */ | ||
| 3166 |
2/2✓ Branch 0 taken 121 times.
✓ Branch 1 taken 8136 times.
|
8257 | for (unsigned i = 0; i < ic->nb_stream_groups; i++) { |
| 3167 | 121 | AVStreamGroup *const stg = ic->stream_groups[i]; | |
| 3168 | AVStreamGroupLayeredVideo *lcevc; | ||
| 3169 | const AVStream *st; | ||
| 3170 | |||
| 3171 |
2/2✓ Branch 0 taken 115 times.
✓ Branch 1 taken 6 times.
|
121 | if (stg->type != AV_STREAM_GROUP_PARAMS_LCEVC) |
| 3172 | 115 | continue; | |
| 3173 | |||
| 3174 | /* For LCEVC in mpegts, the parser is needed to get the enhancement layer | ||
| 3175 | * dimensions */ | ||
| 3176 | 6 | lcevc = stg->params.layered_video; | |
| 3177 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
6 | if (lcevc->width && lcevc->height) |
| 3178 | ✗ | continue; | |
| 3179 | 6 | st = stg->streams[lcevc->el_index]; | |
| 3180 | 6 | lcevc->width = st->codecpar->width; | |
| 3181 | 6 | lcevc->height = st->codecpar->height; | |
| 3182 | } | ||
| 3183 | |||
| 3184 | 8136 | find_stream_info_err: | |
| 3185 |
2/2✓ Branch 0 taken 9038 times.
✓ Branch 1 taken 8136 times.
|
17174 | for (unsigned i = 0; i < ic->nb_streams; i++) { |
| 3186 | 9038 | AVStream *const st = ic->streams[i]; | |
| 3187 | 9038 | FFStream *const sti = ffstream(st); | |
| 3188 | int err; | ||
| 3189 | |||
| 3190 |
1/2✓ Branch 0 taken 9038 times.
✗ Branch 1 not taken.
|
9038 | if (sti->info) { |
| 3191 | 9038 | av_freep(&sti->info->duration_error); | |
| 3192 | 9038 | av_freep(&sti->info); | |
| 3193 | } | ||
| 3194 | |||
| 3195 |
2/2✓ Branch 1 taken 8911 times.
✓ Branch 2 taken 127 times.
|
9038 | if (avcodec_is_open(sti->avctx)) { |
| 3196 | 8911 | err = codec_close(sti); | |
| 3197 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 8911 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
8911 | if (err < 0 && ret >= 0) |
| 3198 | ✗ | ret = err; | |
| 3199 | } | ||
| 3200 | |||
| 3201 | 9038 | av_bsf_free(&sti->extract_extradata.bsf); | |
| 3202 | } | ||
| 3203 |
2/2✓ Branch 0 taken 4939 times.
✓ Branch 1 taken 3197 times.
|
8136 | if (ic->pb) { |
| 3204 | 4939 | FFIOContext *const ctx = ffiocontext(ic->pb); | |
| 3205 | 4939 | av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n", | |
| 3206 | avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, count); | ||
| 3207 | } | ||
| 3208 | 8136 | return ret; | |
| 3209 | |||
| 3210 | ✗ | unref_then_goto_end: | |
| 3211 | ✗ | av_packet_unref(pkt1); | |
| 3212 | ✗ | goto find_stream_info_err; | |
| 3213 | } | ||
| 3214 |