FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavformat/demux.c
Date: 2026-09-27 12:50:02
Exec Total Coverage
Lines: 1725 1967 87.7%
Functions: 50 50 100.0%
Branches: 1573 1929 81.5%
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 2632640 static int64_t wrap_timestamp(const AVStream *st, int64_t timestamp)
54 {
55 2632640 const FFStream *const sti = cffstream(st);
56
4/4
✓ Branch 0 taken 164801 times.
✓ Branch 1 taken 2467839 times.
✓ Branch 2 taken 159797 times.
✓ Branch 3 taken 5004 times.
 2632640 if (sti->pts_wrap_behavior != AV_PTS_WRAP_IGNORE && st->pts_wrap_bits < 64 &&
57
4/4
✓ Branch 0 taken 158509 times.
✓ Branch 1 taken 1288 times.
✓ Branch 2 taken 96868 times.
✓ Branch 3 taken 61641 times.
 159797 sti->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
58
2/2
✓ Branch 0 taken 96664 times.
✓ Branch 1 taken 204 times.
 96868 if (sti->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
59
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 96664 times.
 96664 timestamp < sti->pts_wrap_reference)
60 ✗ return timestamp + (1ULL << st->pts_wrap_bits);
61
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 96664 times.
 96868 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 2632590 return timestamp;
66 }
67
68 359372 int64_t ff_wrap_timestamp(const AVStream *st, int64_t timestamp)
69 {
70 359372 return wrap_timestamp(st, timestamp);
71 }
72
73 10681 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 368 times.
✓ Branch 1 taken 10313 times.
 10681 if (codec_id == AV_CODEC_ID_H264)
81 368 return avcodec_find_decoder_by_name("h264");
82 #endif
83
84 10313 codec = ff_find_decoder(s, st, codec_id);
85
2/2
✓ Branch 0 taken 225 times.
✓ Branch 1 taken 10088 times.
 10313 if (!codec)
86 225 return NULL;
87
88
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10088 times.
 10088 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 10088 return codec;
101 }
102
103 3374 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 3374 const AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
133 3374 FFStream *const sti = ffstream(st);
134
135
2/2
✓ Branch 0 taken 1186 times.
✓ Branch 1 taken 2188 times.
 3374 if (fmt) {
136 1186 av_log(s, AV_LOG_DEBUG,
137 "Probe with size=%d, packets=%d detected %s with score=%d\n",
138 1186 pd->buf_size, s->max_probe_packets - sti->probe_packets,
139 1186 fmt->name, score);
140
2/2
✓ Branch 0 taken 21166 times.
✓ Branch 1 taken 1159 times.
 22325 for (int i = 0; fmt_id_type[i].name; i++) {
141
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 21133 times.
 21166 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
142
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 20 times.
 33 if (fmt_id_type[i].type != AVMEDIA_TYPE_AUDIO &&
143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
 13 st->codecpar->sample_rate)
144 ✗ continue;
145
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 23 times.
 33 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 27 st->codecpar->codec_id = fmt_id_type[i].id;
149 27 st->codecpar->codec_type = fmt_id_type[i].type;
150 27 sti->need_context_update = 1;
151 27 return score;
152 }
153 }
154 }
155 3347 return 0;
156 }
157
158 8284 static int init_input(AVFormatContext *s, const char *filename,
159 AVDictionary **options)
160 {
161 int ret;
162 8284 AVProbeData pd = { filename, NULL, 0 };
163 8284 int score = AVPROBE_SCORE_RETRY;
164
165
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 8267 times.
 8284 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 3971 times.
✓ Branch 1 taken 4296 times.
✓ Branch 2 taken 972 times.
✓ Branch 3 taken 2999 times.
 8267 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
177
4/4
✓ Branch 0 taken 4296 times.
✓ Branch 1 taken 972 times.
✓ Branch 3 taken 199 times.
✓ Branch 4 taken 4097 times.
 5268 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
178 3198 return score;
179
180
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 5069 times.
 5069 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 972 times.
✓ Branch 1 taken 4097 times.
 5069 if (s->iformat)
184 972 return 0;
185 4097 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
186 4097 s, 0, s->format_probesize);
187 }
188
189 static int codec_close(FFStream *sti);
190
191 218858 static int update_stream_avctx(AVFormatContext *s)
192 {
193 int ret;
194
2/2
✓ Branch 0 taken 263979 times.
✓ Branch 1 taken 218858 times.
 482837 for (unsigned i = 0; i < s->nb_streams; i++) {
195 263979 AVStream *const st = s->streams[i];
196 263979 FFStream *const sti = ffstream(st);
197
198
2/2
✓ Branch 0 taken 254835 times.
✓ Branch 1 taken 9144 times.
 263979 if (!sti->need_context_update)
199 254835 continue;
200
201
2/2
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 9142 times.
 9144 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 9142 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 9144 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 9144 ret = avcodec_parameters_to_context(sti->avctx, st->codecpar);
217
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9144 times.
 9144 if (ret < 0)
218 ✗ return ret;
219
220 9144 sti->codec_desc = avcodec_descriptor_get(sti->avctx->codec_id);
221
222 9144 sti->need_context_update = 0;
223 }
224 218858 return 0;
225 }
226
227 5086 static av_always_inline int is_id3v2_format(const AVInputFormat *fmt) {
228 5086 return ffifmt(fmt)->flags_internal & FF_INFMT_FLAG_ID3V2_AUTO;
229 }
230
231 8284 int avformat_open_input(AVFormatContext **ps, const char *filename,
232 const AVInputFormat *fmt, AVDictionary **options)
233 {
234 FormatContextInternal *fci;
235 8284 AVFormatContext *s = *ps;
236 FFFormatContext *si;
237 8284 AVDictionary *tmp = NULL;
238 8284 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
239 8284 int ret = 0;
240
241
3/4
✓ Branch 0 taken 29 times.
✓ Branch 1 taken 8255 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 29 times.
 8284 if (!s && !(s = avformat_alloc_context()))
242 ✗ return AVERROR(ENOMEM);
243 8284 fci = ff_fc_internal(s);
244 8284 si = &fci->fc;
245
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8284 times.
 8284 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 3988 times.
✓ Branch 1 taken 4296 times.
 8284 if (fmt)
250 3988 s->iformat = fmt;
251
252
2/2
✓ Branch 0 taken 8268 times.
✓ Branch 1 taken 16 times.
 8284 if (options)
253 8268 av_dict_copy(&tmp, *options, 0);
254
255
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 8267 times.
 8284 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 8284 times.
 8284 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
259 ✗ goto fail;
260
261
2/4
✓ Branch 0 taken 8284 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 8284 times.
 8284 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 8284 times.
 8284 if ((ret = init_input(s, filename, &tmp)) < 0)
267 ✗ goto fail;
268 8284 s->probe_score = ret;
269
270
6/6
✓ Branch 0 taken 8192 times.
✓ Branch 1 taken 92 times.
✓ Branch 2 taken 4994 times.
✓ Branch 3 taken 3198 times.
✓ Branch 4 taken 4993 times.
✓ Branch 5 taken 1 times.
 8284 if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) {
271 4993 s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
272
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4993 times.
 4993 if (!s->protocol_whitelist) {
273 ✗ ret = AVERROR(ENOMEM);
274 ✗ goto fail;
275 }
276 }
277
278
4/6
✓ Branch 0 taken 8284 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5086 times.
✓ Branch 3 taken 3198 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5086 times.
 8284 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 8284 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 8284 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 8284 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 8284 times.
 8284 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
296 ✗ if (!av_filename_number_test(filename)) {
297 ✗ ret = AVERROR(EINVAL);
298 ✗ goto fail;
299 }
300 }
301
302 8284 s->duration = s->start_time = AV_NOPTS_VALUE;
303
304 /* Allocate private data. */
305
2/2
✓ Branch 1 taken 8100 times.
✓ Branch 2 taken 184 times.
 8284 if (ffifmt(s->iformat)->priv_data_size > 0) {
306
1/2
✗ Branch 2 not taken.
✓ Branch 3 taken 8100 times.
 8100 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 7116 times.
✓ Branch 1 taken 984 times.
 8100 if (s->iformat->priv_class) {
311 7116 *(const AVClass **) s->priv_data = s->iformat->priv_class;
312 7116 av_opt_set_defaults(s->priv_data);
313
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 7116 times.
 7116 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 5086 times.
✓ Branch 1 taken 3198 times.
✓ Branch 3 taken 793 times.
✓ Branch 4 taken 4293 times.
 8284 if (s->pb && is_id3v2_format(s->iformat))
320 793 ff_id3v2_read_dict(s, s->pb, &si->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
321
322
1/2
✓ Branch 1 taken 8284 times.
✗ Branch 2 not taken.
 8284 if (ffifmt(s->iformat)->read_header)
323
2/2
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 8283 times.
 8284 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 6705 times.
✓ Branch 1 taken 1578 times.
 8283 if (!s->metadata) {
330 6705 s->metadata = si->id3v2_meta;
331 6705 si->id3v2_meta = NULL;
332
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1578 times.
 1578 } 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 32 times.
✓ Branch 1 taken 8251 times.
 8283 if (id3v2_extra_meta) {
338
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
 32 if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
339 ✗ goto close;
340
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
 32 if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
341 ✗ goto close;
342
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 32 times.
 32 if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
343 ✗ goto close;
344 32 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
345 }
346
347
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 8283 times.
 8283 if ((ret = avformat_queue_attached_pictures(s)) < 0)
348 ✗ goto close;
349
350
4/4
✓ Branch 0 taken 5085 times.
✓ Branch 1 taken 3198 times.
✓ Branch 2 taken 4549 times.
✓ Branch 3 taken 536 times.
 8283 if (s->pb && !si->data_offset)
351 4549 si->data_offset = avio_tell(s->pb);
352
353 8283 fci->raw_packet_buffer_size = 0;
354
355 8283 update_stream_avctx(s);
356
357
2/2
✓ Branch 0 taken 8267 times.
✓ Branch 1 taken 16 times.
 8283 if (options) {
358 8267 av_dict_free(options);
359 8267 *options = tmp;
360 }
361 8283 *ps = s;
362 8283 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 8285 void avformat_close_input(AVFormatContext **ps)
378 {
379 AVFormatContext *s;
380 AVIOContext *pb;
381
382
3/4
✓ Branch 0 taken 8285 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8283 times.
 8285 if (!ps || !*ps)
383 2 return;
384
385 8283 s = *ps;
386 8283 pb = s->pb;
387
388
5/6
✓ Branch 0 taken 8283 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5133 times.
✓ Branch 3 taken 3150 times.
✓ Branch 4 taken 5058 times.
✓ Branch 5 taken 75 times.
 8283 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
389
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 8191 times.
 8208 (s->flags & AVFMT_FLAG_CUSTOM_IO))
390 92 pb = NULL;
391
392
1/2
✓ Branch 0 taken 8283 times.
✗ Branch 1 not taken.
 8283 if (s->iformat)
393
2/2
✓ Branch 1 taken 5361 times.
✓ Branch 2 taken 2922 times.
 8283 if (ffifmt(s->iformat)->read_close)
394 5361 ffifmt(s->iformat)->read_close(s);
395
396 8283 ff_format_io_close(s, &pb);
397 8283 avformat_free_context(s);
398
399 8283 *ps = NULL;
400 }
401
402 1140007 static void force_codec_ids(AVFormatContext *s, AVStream *st)
403 {
404
5/5
✓ Branch 0 taken 755784 times.
✓ Branch 1 taken 380560 times.
✓ Branch 2 taken 3451 times.
✓ Branch 3 taken 210 times.
✓ Branch 4 taken 2 times.
 1140007 switch (st->codecpar->codec_type) {
405 755784 case AVMEDIA_TYPE_VIDEO:
406
2/2
✓ Branch 0 taken 117995 times.
✓ Branch 1 taken 637789 times.
 755784 if (s->video_codec_id)
407 117995 st->codecpar->codec_id = s->video_codec_id;
408 755784 break;
409 380560 case AVMEDIA_TYPE_AUDIO:
410
2/2
✓ Branch 0 taken 4620 times.
✓ Branch 1 taken 375940 times.
 380560 if (s->audio_codec_id)
411 4620 st->codecpar->codec_id = s->audio_codec_id;
412 380560 break;
413 3451 case AVMEDIA_TYPE_SUBTITLE:
414
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3451 times.
 3451 if (s->subtitle_codec_id)
415 ✗ st->codecpar->codec_id = s->subtitle_codec_id;
416 3451 break;
417 210 case AVMEDIA_TYPE_DATA:
418
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 210 times.
 210 if (s->data_codec_id)
419 ✗ st->codecpar->codec_id = s->data_codec_id;
420 210 break;
421 }
422 1140007 }
423
424 23902 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
425 {
426 23902 FormatContextInternal *const fci = ff_fc_internal(s);
427 23902 FFStream *const sti = ffstream(st);
428
429
2/2
✓ Branch 0 taken 17659 times.
✓ Branch 1 taken 6243 times.
 23902 if (sti->request_probe > 0) {
430 17659 AVProbeData *const pd = &sti->probe_data;
431 int end;
432 17659 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, sti->probe_packets);
433 17659 --sti->probe_packets;
434
435
2/2
✓ Branch 0 taken 17642 times.
✓ Branch 1 taken 17 times.
 17659 if (pkt) {
436 17642 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 17642 times.
 17642 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 17642 pd->buf = new_buf;
444 17642 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
445 17642 pd->buf_size += pkt->size;
446 17642 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 17659 times.
✗ Branch 1 not taken.
 35318 end = fci->raw_packet_buffer_size >= s->probesize ||
457
2/2
✓ Branch 0 taken 554 times.
✓ Branch 1 taken 17105 times.
 17659 sti->probe_packets <= 0;
458
459
4/4
✓ Branch 0 taken 17105 times.
✓ Branch 1 taken 554 times.
✓ Branch 2 taken 2820 times.
✓ Branch 3 taken 14285 times.
 17659 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
460 3374 int score = set_codec_from_probe_data(s, st, pd);
461
4/4
✓ Branch 0 taken 3366 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 3343 times.
✓ Branch 3 taken 23 times.
 3374 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 577 pd->buf_size = 0;
464 577 av_freep(&pd->buf);
465 577 sti->request_probe = -1;
466
1/2
✓ Branch 0 taken 577 times.
✗ Branch 1 not taken.
 577 if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
467 577 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 3374 force_codec_ids(s, st);
472 }
473 }
474 23902 return 0;
475 }
476
477 1136633 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
478 {
479 1136633 FFStream *const sti = ffstream(st);
480 1136633 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 929119 times.
✓ Branch 1 taken 207514 times.
 1136633 if (ref == AV_NOPTS_VALUE)
486 929119 ref = pkt->pts;
487
7/8
✓ Branch 0 taken 1062762 times.
✓ Branch 1 taken 73871 times.
✓ Branch 2 taken 58870 times.
✓ Branch 3 taken 1003892 times.
✓ Branch 4 taken 995 times.
✓ Branch 5 taken 57875 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 995 times.
 1136633 if (sti->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
488 1135638 return 0;
489 995 ref &= (1LL << st->pts_wrap_bits)-1;
490
491 // reference time stamp should be 60 s before first time stamp
492 995 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 1991 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 994 times.
 996 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
497
498 995 first_program = av_find_program_from_stream(s, NULL, stream_index);
499
500
2/2
✓ Branch 0 taken 215 times.
✓ Branch 1 taken 780 times.
 995 if (!first_program) {
501 215 int default_stream_index = av_find_default_stream_index(s);
502 215 FFStream *const default_sti = ffstream(s->streams[default_stream_index]);
503
2/2
✓ Branch 0 taken 204 times.
✓ Branch 1 taken 11 times.
 215 if (default_sti->pts_wrap_reference == AV_NOPTS_VALUE) {
504
2/2
✓ Branch 0 taken 397 times.
✓ Branch 1 taken 204 times.
 601 for (unsigned i = 0; i < s->nb_streams; i++) {
505 397 FFStream *const sti = ffstream(s->streams[i]);
506
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 397 times.
 397 if (av_find_program_from_stream(s, NULL, i))
507 ✗ continue;
508 397 sti->pts_wrap_reference = pts_wrap_reference;
509 397 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 780 AVProgram *program = first_program;
517
2/2
✓ Branch 0 taken 780 times.
✓ Branch 1 taken 96 times.
 876 while (program) {
518
2/2
✓ Branch 0 taken 684 times.
✓ Branch 1 taken 96 times.
 780 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
519 684 pts_wrap_reference = program->pts_wrap_reference;
520 684 pts_wrap_behavior = program->pts_wrap_behavior;
521 684 break;
522 }
523 96 program = av_find_program_from_stream(s, program, stream_index);
524 }
525
526 // update every program with differing pts_wrap_reference
527 780 program = first_program;
528
2/2
✓ Branch 0 taken 780 times.
✓ Branch 1 taken 780 times.
 1560 while (program) {
529
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 684 times.
 780 if (program->pts_wrap_reference != pts_wrap_reference) {
530
2/2
✓ Branch 0 taken 147 times.
✓ Branch 1 taken 96 times.
 243 for (unsigned i = 0; i < program->nb_stream_indexes; i++) {
531 147 FFStream *const sti = ffstream(s->streams[program->stream_index[i]]);
532 147 sti->pts_wrap_reference = pts_wrap_reference;
533 147 sti->pts_wrap_behavior = pts_wrap_behavior;
534 }
535
536 96 program->pts_wrap_reference = pts_wrap_reference;
537 96 program->pts_wrap_behavior = pts_wrap_behavior;
538 }
539 780 program = av_find_program_from_stream(s, program, stream_index);
540 }
541 }
542 995 return 1;
543 }
544
545 1136633 static void update_timestamps(AVFormatContext *s, AVStream *st, AVPacket *pkt)
546 {
547 1136633 FFStream *const sti = ffstream(st);
548
549
4/4
✓ Branch 1 taken 995 times.
✓ Branch 2 taken 1135638 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 994 times.
 1136633 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 1136633 pkt->dts = wrap_timestamp(st, pkt->dts);
560 1136633 pkt->pts = wrap_timestamp(st, pkt->pts);
561
562 1136633 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 1136633 times.
 1136633 if (s->use_wallclock_as_timestamps)
566 ✗ pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
567 1136633 }
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 1136633 static int handle_new_packet(AVFormatContext *s, AVPacket *pkt, int allow_passthrough)
578 {
579 1136633 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 1136633 times.
 1136633 av_assert0(pkt->stream_index < (unsigned)s->nb_streams &&
585 "Invalid stream index.\n");
586
587
2/2
✓ Branch 0 taken 211 times.
✓ Branch 1 taken 1136422 times.
 1136633 if (pkt->flags & AV_PKT_FLAG_CORRUPT) {
588 422 av_log(s, AV_LOG_WARNING,
589 "Packet corrupt (stream = %d, dts = %s)%s.\n",
590 211 pkt->stream_index, av_ts2str(pkt->dts),
591
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 211 times.
 211 s->flags & AVFMT_FLAG_DISCARD_CORRUPT ? ", dropping it" : "");
592
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 211 times.
 211 if (s->flags & AVFMT_FLAG_DISCARD_CORRUPT) {
593 ✗ av_packet_unref(pkt);
594 ✗ return 1;
595 }
596 }
597
598 1136633 st = s->streams[pkt->stream_index];
599 1136633 sti = ffstream(st);
600
601 1136633 update_timestamps(s, st, pkt);
602
603
6/6
✓ Branch 0 taken 1118991 times.
✓ Branch 1 taken 17642 times.
✓ Branch 2 taken 1112790 times.
✓ Branch 3 taken 6201 times.
✓ Branch 4 taken 1112748 times.
✓ Branch 5 taken 42 times.
 1136633 if (sti->request_probe <= 0 && allow_passthrough && !fci->raw_packet_buffer.head)
604 1112748 return 0;
605
606 23885 err = ff_packet_list_put(&fci->raw_packet_buffer, pkt, NULL, 0);
607
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23885 times.
 23885 if (err < 0) {
608 ✗ av_packet_unref(pkt);
609 ✗ return err;
610 }
611
612 23885 pkt = &fci->raw_packet_buffer.tail->pkt;
613 23885 fci->raw_packet_buffer_size += pkt->size;
614
615 23885 err = probe_codec(s, st, pkt);
616
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23885 times.
 23885 if (err < 0)
617 ✗ return err;
618
619 23885 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 1143922 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
630 {
631 1143922 FormatContextInternal *const fci = ff_fc_internal(s);
632 int err;
633
634 #if FF_API_INIT_PACKET
635 FF_DISABLE_DEPRECATION_WARNINGS
636 1143922 pkt->data = NULL;
637 1143922 pkt->size = 0;
638 1143922 av_init_packet(pkt);
639 FF_ENABLE_DEPRECATION_WARNINGS
640 #else
641 av_packet_unref(pkt);
642 #endif
643
644 24150 for (;;) {
645 1168072 PacketListEntry *pktl = fci->raw_packet_buffer.head;
646
647
2/2
✓ Branch 0 taken 41066 times.
✓ Branch 1 taken 1127006 times.
 1168072 if (pktl) {
648 41066 AVStream *const st = s->streams[pktl->pkt.stream_index];
649
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 41066 times.
 41066 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 23942 times.
✓ Branch 2 taken 17124 times.
 41066 if (ffstream(st)->request_probe <= 0) {
653 23942 ff_packet_list_get(&fci->raw_packet_buffer, pkt);
654 23942 fci->raw_packet_buffer_size -= pkt->size;
655 23942 return 0;
656 }
657 }
658
659 1144130 err = ffifmt(s->iformat)->read_packet(s, pkt);
660
2/2
✓ Branch 0 taken 13698 times.
✓ Branch 1 taken 1130432 times.
 1144130 if (err < 0) {
661 13698 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 7249 times.
 13698 if (err == FFERROR_REDO)
667 6449 continue;
668
3/4
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 7232 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 17 times.
 7249 if (!pktl || err == AVERROR(EAGAIN))
669 7232 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 1130432 err = av_packet_make_refcounted(pkt);
682
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1130432 times.
 1130432 if (err < 0) {
683 ✗ av_packet_unref(pkt);
684 ✗ return err;
685 }
686
687 1130432 err = handle_new_packet(s, pkt, 1);
688
2/2
✓ Branch 0 taken 1112748 times.
✓ Branch 1 taken 17684 times.
 1130432 if (err <= 0) /* Error or passthrough */
689 1112748 return err;
690 }
691 }
692
693 /**
694 * Return the frame duration in seconds. Return 0 if not available.
695 */
696 337324 static void compute_frame_duration(AVFormatContext *s, int *pnum, int *pden,
697 AVStream *st, AVCodecParserContext *pc,
698 AVPacket *pkt)
699 {
700 337324 FFStream *const sti = ffstream(st);
701 337324 AVRational codec_framerate = sti->avctx->framerate;
702 int frame_size, sample_rate;
703
704 337324 *pnum = 0;
705 337324 *pden = 0;
706
3/3
✓ Branch 0 taken 227251 times.
✓ Branch 1 taken 108476 times.
✓ Branch 2 taken 1597 times.
 337324 switch (st->codecpar->codec_type) {
707 227251 case AVMEDIA_TYPE_VIDEO:
708
6/6
✓ Branch 0 taken 195676 times.
✓ Branch 1 taken 31575 times.
✓ Branch 2 taken 43397 times.
✓ Branch 3 taken 152279 times.
✓ Branch 4 taken 31089 times.
✓ Branch 5 taken 12308 times.
 227251 if (st->r_frame_rate.num && (!pc || !codec_framerate.num)) {
709 183368 *pnum = st->r_frame_rate.den;
710 183368 *pden = st->r_frame_rate.num;
711
2/2
✓ Branch 0 taken 24719 times.
✓ Branch 1 taken 19164 times.
 43883 } else if ((s->iformat->flags & AVFMT_NOTIMESTAMPS) &&
712
2/2
✓ Branch 0 taken 15293 times.
✓ Branch 1 taken 9426 times.
 24719 !codec_framerate.num &&
713
3/4
✓ Branch 0 taken 15291 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 15291 times.
✗ Branch 3 not taken.
 15293 st->avg_frame_rate.num && st->avg_frame_rate.den) {
714 15291 *pnum = st->avg_frame_rate.den;
715 15291 *pden = st->avg_frame_rate.num;
716
2/2
✓ Branch 0 taken 9325 times.
✓ Branch 1 taken 19267 times.
 28592 } else if (st->time_base.num * 1000LL > st->time_base.den) {
717 9325 *pnum = st->time_base.num;
718 9325 *pden = st->time_base.den;
719
2/2
✓ Branch 0 taken 19242 times.
✓ Branch 1 taken 25 times.
 19267 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
720 57726 int ticks_per_frame = (sti->codec_desc &&
721
3/4
✓ Branch 0 taken 19242 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 13290 times.
✓ Branch 3 taken 5952 times.
 19242 (sti->codec_desc->props & AV_CODEC_PROP_FIELDS)) ? 2 : 1;
722 19242 av_reduce(pnum, pden,
723 19242 codec_framerate.den,
724 19242 codec_framerate.num * (int64_t)ticks_per_frame,
725 INT_MAX);
726
727
4/4
✓ Branch 0 taken 17408 times.
✓ Branch 1 taken 1834 times.
✓ Branch 2 taken 12660 times.
✓ Branch 3 taken 4748 times.
 19242 if (pc && pc->repeat_pict) {
728 12660 av_reduce(pnum, pden,
729 12660 (*pnum) * (1LL + pc->repeat_pict),
730 12660 (*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 19242 times.
✗ Branch 1 not taken.
 19242 if (sti->codec_desc &&
737
3/4
✓ Branch 0 taken 13290 times.
✓ Branch 1 taken 5952 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 13290 times.
 19242 (sti->codec_desc->props & AV_CODEC_PROP_FIELDS) && !pc)
738 ✗ *pnum = *pden = 0;
739 }
740 227251 break;
741 108476 case AVMEDIA_TYPE_AUDIO:
742
2/2
✓ Branch 0 taken 47088 times.
✓ Branch 1 taken 61388 times.
 108476 if (sti->avctx_inited) {
743 47088 frame_size = av_get_audio_frame_duration(sti->avctx, pkt->size);
744 47088 sample_rate = sti->avctx->sample_rate;
745 } else {
746 61388 frame_size = av_get_audio_frame_duration2(st->codecpar, pkt->size);
747 61388 sample_rate = st->codecpar->sample_rate;
748 }
749
4/4
✓ Branch 0 taken 103035 times.
✓ Branch 1 taken 5441 times.
✓ Branch 2 taken 103030 times.
✓ Branch 3 taken 5 times.
 108476 if (frame_size <= 0 || sample_rate <= 0)
750 break;
751 103030 *pnum = frame_size;
752 103030 *pden = sample_rate;
753 103030 break;
754 1597 default:
755 1597 break;
756 }
757 337324 }
758
759 807892 static int has_decode_delay_been_guessed(AVStream *st)
760 {
761 807892 FFStream *const sti = ffstream(st);
762
2/2
✓ Branch 0 taken 789974 times.
✓ Branch 1 taken 17918 times.
 807892 if (st->codecpar->codec_id != AV_CODEC_ID_H264) return 1;
763
2/2
✓ Branch 0 taken 6374 times.
✓ Branch 1 taken 11544 times.
 17918 if (!sti->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
764 6374 return 1;
765
1/6
✗ Branch 0 not taken.
✓ Branch 1 taken 11544 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 11544 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 7088 times.
✓ Branch 1 taken 4456 times.
✓ Branch 3 taken 6963 times.
✓ Branch 4 taken 125 times.
 11544 if (sti->avctx->has_b_frames && avcodec_is_open(sti->avctx) &&
768
2/2
✓ Branch 1 taken 1717 times.
✓ Branch 2 taken 5246 times.
 6963 avpriv_h264_has_num_reorder_frames(sti->avctx) == sti->avctx->has_b_frames)
769 1717 return 1;
770 #endif
771
2/2
✓ Branch 0 taken 9637 times.
✓ Branch 1 taken 190 times.
 9827 if (sti->avctx->has_b_frames < 3)
772 9637 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 37639 static PacketListEntry *get_next_pkt(AVFormatContext *s, AVStream *st,
780 PacketListEntry *pktl)
781 {
782 37639 FormatContextInternal *const fci = ff_fc_internal(s);
783 37639 FFFormatContext *const si = &fci->fc;
784
2/2
✓ Branch 0 taken 35471 times.
✓ Branch 1 taken 2168 times.
 37639 if (pktl->next)
785 35471 return pktl->next;
786
2/2
✓ Branch 0 taken 2136 times.
✓ Branch 1 taken 32 times.
 2168 if (pktl == si->packet_buffer.tail)
787 2136 return fci->parse_queue.head;
788 32 return NULL;
789 }
790
791 598556 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts)
792 {
793 598556 FFStream *const sti = ffstream(st);
794 1787920 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
795
4/4
✓ Branch 0 taken 590808 times.
✓ Branch 1 taken 7748 times.
✓ Branch 2 taken 589113 times.
✓ Branch 3 taken 1695 times.
 1187669 st->codecpar->codec_id != AV_CODEC_ID_HEVC &&
796
2/2
✓ Branch 0 taken 588897 times.
✓ Branch 1 taken 216 times.
 589113 st->codecpar->codec_id != AV_CODEC_ID_VVC;
797
798
2/2
✓ Branch 0 taken 9659 times.
✓ Branch 1 taken 588897 times.
 598556 if (!onein_oneout) {
799 9659 int delay = sti->avctx->has_b_frames;
800
801
2/2
✓ Branch 0 taken 1398 times.
✓ Branch 1 taken 8261 times.
 9659 if (dts == AV_NOPTS_VALUE) {
802 1398 int64_t best_score = INT64_MAX;
803
2/2
✓ Branch 0 taken 1697 times.
✓ Branch 1 taken 1398 times.
 3095 for (int i = 0; i < delay; i++) {
804
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1697 times.
 1697 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 14679 times.
✓ Branch 1 taken 8261 times.
 22940 for (int i = 0; i < delay; i++) {
814
2/2
✓ Branch 0 taken 13671 times.
✓ Branch 1 taken 1008 times.
 14679 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 4197 times.
✓ Branch 1 taken 9474 times.
 13671 uint64_t diff = ABSDIFF(pts_buffer[i], dts);
817
818
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 13671 times.
 13671 if (diff > INT64_MAX - sti->pts_reorder_error[i]) {
819 ✗ diff = INT64_MAX;
820 } else
821 13671 diff += sti->pts_reorder_error[i];
822
823 13671 sti->pts_reorder_error[i] = diff;
824 13671 sti->pts_reorder_error_count[i]++;
825
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 13668 times.
 13671 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 1773 times.
✓ Branch 1 taken 596783 times.
 598556 if (dts == AV_NOPTS_VALUE)
835 1773 dts = pts_buffer[0];
836
837 598556 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 6569 static void update_dts_from_pts(AVFormatContext *s, int stream_index,
845 PacketListEntry *pkt_buffer)
846 {
847 6569 AVStream *const st = s->streams[stream_index];
848 6569 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 111673 times.
✓ Branch 1 taken 6569 times.
 118242 for (int i = 0; i < MAX_REORDER_DELAY + 1; i++)
853 111673 pts_buffer[i] = AV_NOPTS_VALUE;
854
855
2/2
✓ Branch 1 taken 5783 times.
✓ Branch 2 taken 6569 times.
 12352 for (; pkt_buffer; pkt_buffer = get_next_pkt(s, st, pkt_buffer)) {
856
2/2
✓ Branch 0 taken 5086 times.
✓ Branch 1 taken 697 times.
 5783 if (pkt_buffer->pkt.stream_index != stream_index)
857 5086 continue;
858
859
3/4
✓ Branch 0 taken 599 times.
✓ Branch 1 taken 98 times.
✓ Branch 2 taken 599 times.
✗ Branch 3 not taken.
 697 if (pkt_buffer->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
860 599 pts_buffer[0] = pkt_buffer->pkt.pts;
861
4/4
✓ Branch 0 taken 419 times.
✓ Branch 1 taken 434 times.
✓ Branch 2 taken 254 times.
✓ Branch 3 taken 165 times.
 853 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 599 pkt_buffer->pkt.dts = select_from_pts_buffer(st, pts_buffer, pkt_buffer->pkt.dts);
865 }
866 }
867 6569 }
868
869 640842 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
870 int64_t dts, int64_t pts, AVPacket *pkt)
871 {
872 640842 FormatContextInternal *const fci = ff_fc_internal(s);
873 640842 FFFormatContext *const si = &fci->fc;
874 640842 AVStream *const st = s->streams[stream_index];
875 640842 FFStream *const sti = ffstream(st);
876
2/2
✓ Branch 0 taken 191693 times.
✓ Branch 1 taken 449149 times.
 640842 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 233255 times.
✓ Branch 1 taken 407587 times.
✓ Branch 2 taken 6651 times.
✓ Branch 3 taken 226604 times.
 640842 if (sti->first_dts != AV_NOPTS_VALUE ||
881 6651 dts == AV_NOPTS_VALUE ||
882
1/2
✓ Branch 0 taken 6651 times.
✗ Branch 1 not taken.
 6651 sti->cur_dts == AV_NOPTS_VALUE ||
883
1/2
✓ Branch 0 taken 6651 times.
✗ Branch 1 not taken.
 6651 sti->cur_dts < INT_MIN + RELATIVE_TS_BASE ||
884
2/4
✓ Branch 0 taken 6651 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6651 times.
 13302 dts < INT_MIN + (sti->cur_dts - RELATIVE_TS_BASE) ||
885 6651 is_relative(dts))
886 634191 return;
887
888 6651 sti->first_dts = dts - (sti->cur_dts - RELATIVE_TS_BASE);
889 6651 sti->cur_dts = dts;
890 6651 shift = (uint64_t)sti->first_dts - RELATIVE_TS_BASE;
891
892
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6651 times.
 6651 if (is_relative(pts))
893 ✗ pts += shift;
894
895
2/2
✓ Branch 1 taken 5511 times.
✓ Branch 2 taken 6651 times.
 12162 for (PacketListEntry *pktl_it = pktl; pktl_it; pktl_it = get_next_pkt(s, st, pktl_it)) {
896
2/2
✓ Branch 0 taken 5017 times.
✓ Branch 1 taken 494 times.
 5511 if (pktl_it->pkt.stream_index != stream_index)
897 5017 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 6548 times.
✓ Branch 2 taken 103 times.
 6651 if (has_decode_delay_been_guessed(st))
912 6548 update_dts_from_pts(s, stream_index, pktl);
913
914
2/2
✓ Branch 0 taken 1894 times.
✓ Branch 1 taken 4757 times.
 6651 if (st->start_time == AV_NOPTS_VALUE) {
915
3/4
✓ Branch 0 taken 1333 times.
✓ Branch 1 taken 561 times.
✓ Branch 2 taken 1333 times.
✗ Branch 3 not taken.
 1894 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO || !(pkt->flags & AV_PKT_FLAG_DISCARD)) {
916 1894 st->start_time = pts;
917 }
918
4/4
✓ Branch 0 taken 561 times.
✓ Branch 1 taken 1333 times.
✓ Branch 2 taken 463 times.
✓ Branch 3 taken 98 times.
 1894 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && st->codecpar->sample_rate)
919 463 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 277940 static void update_initial_durations(AVFormatContext *s, AVStream *st,
924 int stream_index, int64_t duration)
925 {
926 277940 FormatContextInternal *const fci = ff_fc_internal(s);
927 277940 FFFormatContext *const si = &fci->fc;
928 277940 FFStream *const sti = ffstream(st);
929
2/2
✓ Branch 0 taken 188448 times.
✓ Branch 1 taken 89492 times.
 277940 PacketListEntry *pktl = si->packet_buffer.head ? si->packet_buffer.head : fci->parse_queue.head;
930 277940 int64_t cur_dts = RELATIVE_TS_BASE;
931
932
2/2
✓ Branch 0 taken 135123 times.
✓ Branch 1 taken 142817 times.
 277940 if (sti->first_dts != AV_NOPTS_VALUE) {
933
2/2
✓ Branch 0 taken 131316 times.
✓ Branch 1 taken 3807 times.
 135123 if (sti->update_initial_durations_done)
934 131316 return;
935 3807 sti->update_initial_durations_done = 1;
936 3807 cur_dts = sti->first_dts;
937
1/2
✓ Branch 1 taken 5692 times.
✗ Branch 2 not taken.
 5692 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
938
2/2
✓ Branch 0 taken 3823 times.
✓ Branch 1 taken 1869 times.
 5692 if (pktl->pkt.stream_index == stream_index) {
939
2/2
✓ Branch 0 taken 3682 times.
✓ Branch 1 taken 141 times.
 3823 if (pktl->pkt.pts != pktl->pkt.dts ||
940
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 3666 times.
 3682 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 3807 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 41 times.
✓ Branch 3 taken 3766 times.
 3807 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 3766 times.
 3766 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 3742 times.
✓ Branch 1 taken 24 times.
 3766 pktl = si->packet_buffer.head ? si->packet_buffer.head : fci->parse_queue.head;
956 3766 sti->first_dts = cur_dts;
957
2/2
✓ Branch 0 taken 117155 times.
✓ Branch 1 taken 25662 times.
 142817 } else if (sti->cur_dts != RELATIVE_TS_BASE)
958 117155 return;
959
960
2/2
✓ Branch 1 taken 53150 times.
✓ Branch 2 taken 738 times.
 53888 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
961
2/2
✓ Branch 0 taken 24263 times.
✓ Branch 1 taken 28887 times.
 53150 if (pktl->pkt.stream_index != stream_index)
962 24263 continue;
963
2/2
✓ Branch 0 taken 832 times.
✓ Branch 1 taken 28055 times.
 28887 if ((pktl->pkt.pts == pktl->pkt.dts ||
964
2/2
✓ Branch 0 taken 14 times.
✓ Branch 1 taken 818 times.
 832 pktl->pkt.pts == AV_NOPTS_VALUE) &&
965
2/2
✓ Branch 0 taken 3814 times.
✓ Branch 1 taken 24255 times.
 28069 (pktl->pkt.dts == AV_NOPTS_VALUE ||
966
2/2
✓ Branch 0 taken 179 times.
✓ Branch 1 taken 3635 times.
 3814 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 197 times.
✓ Branch 1 taken 27695 times.
 27892 !pktl->pkt.duration &&
969
1/2
✓ Branch 1 taken 197 times.
✗ Branch 2 not taken.
 197 av_sat_add64(cur_dts, duration) == cur_dts + (uint64_t)duration
970 ) {
971 197 pktl->pkt.dts = cur_dts;
972
2/2
✓ Branch 0 taken 181 times.
✓ Branch 1 taken 16 times.
 197 if (!sti->avctx->has_b_frames)
973 181 pktl->pkt.pts = cur_dts;
974 197 pktl->pkt.duration = duration;
975 } else
976 break;
977 197 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
978 }
979
2/2
✓ Branch 0 taken 738 times.
✓ Branch 1 taken 28690 times.
 29428 if (!pktl)
980 738 sti->cur_dts = cur_dts;
981 }
982
983 647238 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 647238 FormatContextInternal *const fci = ff_fc_internal(s);
988 647238 FFFormatContext *const si = &fci->fc;
989 647238 FFStream *const sti = ffstream(st);
990 int num, den, presentation_delayed, delay;
991 int64_t offset;
992 AVRational duration;
993 1906682 int onein_oneout = st->codecpar->codec_id != AV_CODEC_ID_H264 &&
994
4/4
✓ Branch 0 taken 612206 times.
✓ Branch 1 taken 35032 times.
✓ Branch 2 taken 597992 times.
✓ Branch 3 taken 14214 times.
 1245230 st->codecpar->codec_id != AV_CODEC_ID_HEVC &&
995
2/2
✓ Branch 0 taken 594599 times.
✓ Branch 1 taken 3393 times.
 597992 st->codecpar->codec_id != AV_CODEC_ID_VVC;
996
997
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 647238 times.
 647238 if (s->flags & AVFMT_FLAG_NOFILLIN)
998 ✗ return;
999
1000
4/4
✓ Branch 0 taken 252222 times.
✓ Branch 1 taken 395016 times.
✓ Branch 2 taken 75468 times.
✓ Branch 3 taken 176754 times.
 647238 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1001
4/4
✓ Branch 0 taken 43860 times.
✓ Branch 1 taken 31608 times.
✓ Branch 2 taken 42604 times.
✓ Branch 3 taken 1256 times.
 75468 if (pkt->dts == pkt->pts && sti->last_dts_for_order_check != AV_NOPTS_VALUE) {
1002
2/2
✓ Branch 0 taken 42595 times.
✓ Branch 1 taken 9 times.
 42604 if (sti->last_dts_for_order_check <= pkt->dts) {
1003 42595 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 42575 times.
 42604 if (sti->dts_ordered + sti->dts_misordered > 250) {
1012 29 sti->dts_ordered >>= 1;
1013 29 sti->dts_misordered >>= 1;
1014 }
1015 }
1016
1017 75468 sti->last_dts_for_order_check = pkt->dts;
1018
4/4
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 75431 times.
✓ Branch 2 taken 20 times.
✓ Branch 3 taken 17 times.
 75468 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 647238 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 647238 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1023 ✗ pkt->dts = AV_NOPTS_VALUE;
1024
1025
4/4
✓ Branch 0 taken 240098 times.
✓ Branch 1 taken 407140 times.
✓ Branch 2 taken 29396 times.
✓ Branch 3 taken 210702 times.
 647238 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1026
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 29312 times.
 29396 && !sti->avctx->has_b_frames)
1027 //FIXME Set low_delay = 0 when has_b_frames = 1
1028 84 sti->avctx->has_b_frames = 1;
1029
1030 /* do we have a video B-frame ? */
1031 647238 delay = sti->avctx->has_b_frames;
1032 647238 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 49799 times.
✓ Branch 1 taken 597439 times.
✓ Branch 2 taken 45058 times.
✓ Branch 3 taken 4741 times.
 647238 if (delay &&
1037
2/2
✓ Branch 0 taken 15662 times.
✓ Branch 1 taken 29396 times.
 45058 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1038 15662 presentation_delayed = 1;
1039
1040
4/4
✓ Branch 0 taken 351304 times.
✓ Branch 1 taken 295934 times.
✓ Branch 2 taken 171895 times.
✓ Branch 3 taken 179409 times.
 647238 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1041
3/4
✓ Branch 0 taken 30725 times.
✓ Branch 1 taken 141170 times.
✓ Branch 2 taken 30725 times.
✗ Branch 3 not taken.
 171895 st->pts_wrap_bits < 63 && pkt->dts > INT64_MIN + (1LL << st->pts_wrap_bits) &&
1042
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 30725 times.
 30725 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 32025 times.
✓ Branch 1 taken 615213 times.
✓ Branch 2 taken 26142 times.
✓ Branch 3 taken 5883 times.
 647238 if (delay == 1 && pkt->dts == pkt->pts &&
1054
4/4
✓ Branch 0 taken 6735 times.
✓ Branch 1 taken 19407 times.
✓ Branch 2 taken 632 times.
✓ Branch 3 taken 6103 times.
 26142 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1055 632 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 339 times.
 632 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 647238 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1062
2/2
✓ Branch 0 taken 333289 times.
✓ Branch 1 taken 313949 times.
 647238 if (pkt->duration <= 0) {
1063 333289 compute_frame_duration(s, &num, &den, st, pc, pkt);
1064
3/4
✓ Branch 0 taken 323341 times.
✓ Branch 1 taken 9948 times.
✓ Branch 2 taken 323341 times.
✗ Branch 3 not taken.
 333289 if (den && num) {
1065 323341 duration = (AVRational) {num, den};
1066 323341 pkt->duration = av_rescale_rnd(1,
1067 323341 num * (int64_t) st->time_base.den,
1068 323341 den * (int64_t) st->time_base.num,
1069 AV_ROUND_DOWN);
1070 }
1071 }
1072
1073
6/6
✓ Branch 0 taken 634468 times.
✓ Branch 1 taken 12770 times.
✓ Branch 2 taken 446020 times.
✓ Branch 3 taken 188448 times.
✓ Branch 4 taken 89492 times.
✓ Branch 5 taken 356528 times.
 647238 if (pkt->duration > 0 && (si->packet_buffer.head || fci->parse_queue.head))
1074 277940 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 240098 times.
✓ Branch 1 taken 407140 times.
✓ Branch 2 taken 949 times.
✓ Branch 3 taken 239149 times.
✓ Branch 4 taken 949 times.
✗ Branch 5 not taken.
 647238 if (pc && sti->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1079 /* this will estimate bitrate based on this frame's duration and size */
1080 949 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1081
2/2
✓ Branch 0 taken 564 times.
✓ Branch 1 taken 385 times.
 949 if (pkt->pts != AV_NOPTS_VALUE)
1082 564 pkt->pts += offset;
1083
2/2
✓ Branch 0 taken 121 times.
✓ Branch 1 taken 828 times.
 949 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 202334 times.
✓ Branch 1 taken 444904 times.
 647238 if (pkt->dts != AV_NOPTS_VALUE &&
1089
2/2
✓ Branch 0 taken 171873 times.
✓ Branch 1 taken 30461 times.
 202334 pkt->pts != AV_NOPTS_VALUE &&
1090
2/2
✓ Branch 0 taken 6449 times.
✓ Branch 1 taken 165424 times.
 171873 pkt->pts > pkt->dts)
1091 6449 presentation_delayed = 1;
1092
1093
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 647238 times.
 647238 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 49799 times.
✓ Branch 1 taken 597439 times.
✓ Branch 2 taken 32025 times.
✓ Branch 3 taken 17774 times.
✓ Branch 4 taken 28222 times.
✓ Branch 5 taken 3803 times.
✓ Branch 6 taken 590809 times.
✓ Branch 7 taken 34852 times.
 647238 if ((delay == 0 || (delay == 1 && pc)) &&
1102 onein_oneout) {
1103
2/2
✓ Branch 0 taken 6000 times.
✓ Branch 1 taken 584809 times.
 590809 if (presentation_delayed) {
1104 /* DTS = decompression timestamp */
1105 /* PTS = presentation timestamp */
1106
2/2
✓ Branch 0 taken 2845 times.
✓ Branch 1 taken 3155 times.
 6000 if (pkt->dts == AV_NOPTS_VALUE)
1107 2845 pkt->dts = sti->last_IP_pts;
1108 6000 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1109
2/2
✓ Branch 0 taken 2507 times.
✓ Branch 1 taken 3493 times.
 6000 if (pkt->dts == AV_NOPTS_VALUE)
1110 2507 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 393 times.
✓ Branch 1 taken 5607 times.
✓ Branch 2 taken 393 times.
✗ Branch 3 not taken.
 6000 if (sti->last_IP_duration == 0 && (uint64_t)pkt->duration <= INT32_MAX)
1115 393 sti->last_IP_duration = pkt->duration;
1116
1/2
✓ Branch 0 taken 6000 times.
✗ Branch 1 not taken.
 6000 if (pkt->dts != AV_NOPTS_VALUE)
1117 6000 sti->cur_dts = av_sat_add64(pkt->dts, sti->last_IP_duration);
1118
1/2
✓ Branch 0 taken 6000 times.
✗ Branch 1 not taken.
 6000 if (pkt->dts != AV_NOPTS_VALUE &&
1119
2/2
✓ Branch 0 taken 3305 times.
✓ Branch 1 taken 2695 times.
 6000 pkt->pts == AV_NOPTS_VALUE &&
1120
2/2
✓ Branch 0 taken 3303 times.
✓ Branch 1 taken 2 times.
 3305 sti->last_IP_duration > 0 &&
1121
4/4
✓ Branch 0 taken 815 times.
✓ Branch 1 taken 2488 times.
✓ Branch 2 taken 805 times.
✓ Branch 3 taken 10 times.
 3303 ((uint64_t)sti->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1122
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 794 times.
 805 next_dts != next_pts &&
1123 next_pts != AV_NOPTS_VALUE)
1124 11 pkt->pts = next_dts;
1125
1126
1/2
✓ Branch 0 taken 6000 times.
✗ Branch 1 not taken.
 6000 if ((uint64_t)pkt->duration <= INT32_MAX)
1127 6000 sti->last_IP_duration = pkt->duration;
1128 6000 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 249932 times.
✓ Branch 1 taken 334877 times.
 584809 } else if (pkt->pts != AV_NOPTS_VALUE ||
1132
2/2
✓ Branch 0 taken 220344 times.
✓ Branch 1 taken 29588 times.
 249932 pkt->dts != AV_NOPTS_VALUE ||
1133
2/2
✓ Branch 0 taken 217738 times.
✓ Branch 1 taken 2606 times.
 220344 pkt->duration > 0 ) {
1134
1135 /* presentation is not delayed : PTS and DTS are the same */
1136
2/2
✓ Branch 0 taken 247326 times.
✓ Branch 1 taken 334877 times.
 582203 if (pkt->pts == AV_NOPTS_VALUE)
1137 247326 pkt->pts = pkt->dts;
1138 582203 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1139 pkt->pts, pkt);
1140
2/2
✓ Branch 0 taken 217738 times.
✓ Branch 1 taken 364465 times.
 582203 if (pkt->pts == AV_NOPTS_VALUE)
1141 217738 pkt->pts = sti->cur_dts;
1142 582203 pkt->dts = pkt->pts;
1143
3/4
✓ Branch 0 taken 582203 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 582194 times.
✓ Branch 3 taken 9 times.
 582203 if (pkt->pts != AV_NOPTS_VALUE && duration.num >= 0)
1144 582194 sti->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1145 }
1146 }
1147
1148
3/4
✓ Branch 0 taken 598641 times.
✓ Branch 1 taken 48597 times.
✓ Branch 2 taken 598641 times.
✗ Branch 3 not taken.
 647238 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
1149 598641 sti->pts_buffer[0] = pkt->pts;
1150
4/4
✓ Branch 0 taken 25678 times.
✓ Branch 1 taken 592134 times.
✓ Branch 2 taken 19171 times.
✓ Branch 3 taken 6507 times.
 617812 for (int i = 0; i < delay && sti->pts_buffer[i] > sti->pts_buffer[i + 1]; i++)
1151 19171 FFSWAP(int64_t, sti->pts_buffer[i], sti->pts_buffer[i + 1]);
1152
1153
2/2
✓ Branch 1 taken 597957 times.
✓ Branch 2 taken 684 times.
 598641 if (has_decode_delay_been_guessed(st))
1154 597957 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 52639 times.
✓ Branch 1 taken 594599 times.
 647238 if (!onein_oneout)
1158 // This should happen on the first packet
1159 52639 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1160
2/2
✓ Branch 0 taken 9424 times.
✓ Branch 1 taken 637814 times.
 647238 if (pkt->dts > sti->cur_dts)
1161 9424 sti->cur_dts = pkt->dts;
1162
1163
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 647238 times.
 647238 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 647075 times.
✓ Branch 1 taken 163 times.
✓ Branch 3 taken 436641 times.
✓ Branch 4 taken 210434 times.
 647238 if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA || ff_is_intra_only(st->codecpar->codec_id))
1169 436804 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 723614 static int parse_packet(AVFormatContext *s, AVPacket *pkt,
1179 int stream_index, int flush)
1180 {
1181 723614 FormatContextInternal *const fci = ff_fc_internal(s);
1182 723614 AVStream *st = s->streams[stream_index];
1183 723614 FFStream *const sti = ffstream(st);
1184 723614 AVPacket *out_pkt = sti->parse_pkt;
1185 723614 const AVPacketSideData *sd = NULL;
1186 723614 const uint8_t *data = pkt->data;
1187 723614 uint8_t *extradata = sti->avctx->extradata;
1188 723614 int extradata_size = sti->avctx->extradata_size;
1189 723614 int size = pkt->size;
1190 723614 int ret = 0, got_output = flush, pkt_side_data_consumed = 0;
1191
1192
5/6
✓ Branch 0 taken 2499 times.
✓ Branch 1 taken 721115 times.
✓ Branch 2 taken 164 times.
✓ Branch 3 taken 2335 times.
✓ Branch 4 taken 164 times.
✗ Branch 5 not taken.
 723614 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 27794 times.
✓ Branch 1 taken 695820 times.
 723614 if (pkt->side_data_elems)
1206 27794 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 723608 times.
 723614 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 889708 times.
✓ Branch 1 taken 727230 times.
✓ Branch 2 taken 5951 times.
✓ Branch 3 taken 721279 times.
✓ Branch 4 taken 3616 times.
✓ Branch 5 taken 2335 times.
 1616938 while (size > 0 || (flush && got_output)) {
1216 893324 int64_t next_pts = pkt->pts;
1217 893324 int64_t next_dts = pkt->dts;
1218 int len;
1219
1220 893324 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 893324 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1225 893324 pkt->pos = -1;
1226 /* increment read pointer */
1227 av_assert1(data || !len);
1228
2/2
✓ Branch 0 taken 877403 times.
✓ Branch 1 taken 15921 times.
 893324 data = len ? data + len : data;
1229 893324 size -= len;
1230
1231 893324 got_output = !!out_pkt->size;
1232
1233
4/4
✓ Branch 0 taken 38420 times.
✓ Branch 1 taken 854904 times.
✓ Branch 2 taken 16694 times.
✓ Branch 3 taken 21726 times.
 893324 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 10897 times.
✓ Branch 1 taken 5797 times.
 16694 if (!pkt_side_data_consumed) {
1237 10897 pkt_side_data_consumed = 1;
1238 10897 out_pkt->side_data = pkt->side_data;
1239 10897 out_pkt->side_data_elems = pkt->side_data_elems;
1240
2/2
✓ Branch 0 taken 5797 times.
✓ Branch 1 taken 5797 times.
 11594 } else for (int i = 0; i < pkt->side_data_elems; i++) {
1241 5797 const AVPacketSideData *const src_sd = &pkt->side_data[i];
1242 5797 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 5797 times.
 5797 if (!dst_data) {
1244 ✗ ret = AVERROR(ENOMEM);
1245 ✗ goto fail;
1246 }
1247 5797 memcpy(dst_data, src_sd->data, src_sd->size);
1248 }
1249 }
1250
1251
2/2
✓ Branch 0 taken 653390 times.
✓ Branch 1 taken 239934 times.
 893324 if (!out_pkt->size)
1252 653390 continue;
1253
1254
4/4
✓ Branch 0 taken 238653 times.
✓ Branch 1 taken 1281 times.
✓ Branch 2 taken 70154 times.
✓ Branch 3 taken 168499 times.
 239934 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 70154 out_pkt->buf = av_buffer_ref(pkt->buf);
1260
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 70154 times.
 70154 if (!out_pkt->buf) {
1261 ✗ ret = AVERROR(ENOMEM);
1262 ✗ goto fail;
1263 }
1264 } else {
1265 169780 ret = av_packet_make_refcounted(out_pkt);
1266
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 169780 times.
 169780 if (ret < 0)
1267 ✗ goto fail;
1268 }
1269
1270 /* set the duration */
1271
2/2
✓ Branch 0 taken 51250 times.
✓ Branch 1 taken 188684 times.
 239934 out_pkt->duration = (sti->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->duration : 0;
1272
2/2
✓ Branch 0 taken 157617 times.
✓ Branch 1 taken 82317 times.
 239934 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1273
6/6
✓ Branch 0 taken 157478 times.
✓ Branch 1 taken 139 times.
✓ Branch 2 taken 157267 times.
✓ Branch 3 taken 211 times.
✓ Branch 4 taken 145511 times.
✓ Branch 5 taken 11756 times.
 157617 if (sti->avctx->sample_rate > 0 && !out_pkt->duration && sti->parser->duration > 0) {
1274 145511 out_pkt->duration =
1275 145511 av_rescale_q_rnd(sti->parser->duration,
1276 145511 (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 80495 times.
 82317 } 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 239934 out_pkt->stream_index = st->index;
1288 239934 out_pkt->pts = sti->parser->pts;
1289 239934 out_pkt->dts = sti->parser->dts;
1290 239934 out_pkt->pos = sti->parser->pos;
1291 239934 out_pkt->flags |= pkt->flags & (AV_PKT_FLAG_DISCARD | AV_PKT_FLAG_CORRUPT);
1292
1293
2/2
✓ Branch 0 taken 163091 times.
✓ Branch 1 taken 76843 times.
 239934 if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1294 163091 out_pkt->pos = sti->parser->frame_offset;
1295
1296
2/2
✓ Branch 0 taken 228665 times.
✓ Branch 1 taken 11269 times.
 239934 if (sti->parser->key_frame == 1 ||
1297
2/2
✓ Branch 0 taken 144375 times.
✓ Branch 1 taken 84290 times.
 228665 (sti->parser->key_frame == -1 &&
1298
2/2
✓ Branch 0 taken 131864 times.
✓ Branch 1 taken 12511 times.
 144375 sti->parser->pict_type == AV_PICTURE_TYPE_I))
1299 143133 out_pkt->flags |= AV_PKT_FLAG_KEY;
1300
1301
6/6
✓ Branch 0 taken 144375 times.
✓ Branch 1 taken 95559 times.
✓ Branch 2 taken 321 times.
✓ Branch 3 taken 144054 times.
✓ Branch 4 taken 290 times.
✓ Branch 5 taken 31 times.
 239934 if (sti->parser->key_frame == -1 && sti->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1302 290 out_pkt->flags |= AV_PKT_FLAG_KEY;
1303
1304 239934 compute_pkt_fields(s, st, sti->parser, out_pkt, next_dts, next_pts);
1305
1306 239934 ret = ff_packet_list_put(&fci->parse_queue,
1307 out_pkt, NULL, 0);
1308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 239934 times.
 239934 if (ret < 0)
1309 ✗ goto fail;
1310 }
1311
1312 /* end of the stream => close and free the parser */
1313
2/2
✓ Branch 0 taken 721279 times.
✓ Branch 1 taken 2335 times.
 723614 if (flush) {
1314 2335 av_parser_close(sti->parser);
1315 2335 sti->parser = NULL;
1316 }
1317
1318 721279 fail:
1319
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 723608 times.
 723614 if (sd) {
1320 6 sti->avctx->extradata = extradata;
1321 6 sti->avctx->extradata_size = extradata_size;
1322 }
1323
2/2
✓ Branch 0 taken 10897 times.
✓ Branch 1 taken 712717 times.
 723614 if (pkt_side_data_consumed) {
1324 10897 pkt->side_data = NULL;
1325 10897 pkt->side_data_elems = 0;
1326 }
1327
1328
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 723614 times.
 723614 if (ret < 0)
1329 ✗ av_packet_unref(out_pkt);
1330 723614 av_packet_unref(pkt);
1331 723614 return ret;
1332 }
1333
1334 49369 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1335 {
1336 49369 return av_rescale(ts, st->time_base.num * st->codecpar->sample_rate, st->time_base.den);
1337 }
1338
1339 9140 static int codec_close(FFStream *sti)
1340 {
1341 9140 AVCodecContext *avctx_new = NULL;
1342 9140 AVCodecParameters *par_tmp = NULL;
1343 9140 const AVCodec *new_codec = NULL;
1344 int ret;
1345
1346 9140 new_codec =
1347 9140 (sti->avctx->codec_id != sti->pub.codecpar->codec_id) ?
1348
2/2
✓ Branch 0 taken 11 times.
✓ Branch 1 taken 9129 times.
 9140 avcodec_find_decoder(sti->pub.codecpar->codec_id) :
1349 9129 sti->avctx->codec;
1350
1351 9140 avctx_new = avcodec_alloc_context3(new_codec);
1352
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9140 times.
 9140 if (!avctx_new) {
1353 ✗ ret = AVERROR(ENOMEM);
1354 ✗ goto fail;
1355 }
1356
1357 9140 par_tmp = avcodec_parameters_alloc();
1358
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9140 times.
 9140 if (!par_tmp) {
1359 ✗ ret = AVERROR(ENOMEM);
1360 ✗ goto fail;
1361 }
1362
1363 9140 ret = avcodec_parameters_from_context(par_tmp, sti->avctx);
1364
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9140 times.
 9140 if (ret < 0)
1365 ✗ goto fail;
1366
1367 9140 ret = avcodec_parameters_to_context(avctx_new, par_tmp);
1368
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9140 times.
 9140 if (ret < 0)
1369 ✗ goto fail;
1370
1371 9140 avctx_new->pkt_timebase = sti->avctx->pkt_timebase;
1372
1373 9140 avcodec_free_context(&sti->avctx);
1374 9140 sti->avctx = avctx_new;
1375
1376 9140 avctx_new = NULL;
1377 9140 ret = 0;
1378
1379 9140 fail:
1380 9140 avcodec_free_context(&avctx_new);
1381 9140 avcodec_parameters_free(&par_tmp);
1382
1383 9140 return ret;
1384 }
1385
1386 static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt);
1387
1388 652251 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1389 {
1390 652251 FormatContextInternal *const fci = ff_fc_internal(s);
1391 652251 FFFormatContext *const si = &fci->fc;
1392 652251 int ret, got_packet = 0;
1393 652251 AVDictionary *metadata = NULL;
1394
1395
4/4
✓ Branch 0 taken 1373663 times.
✓ Branch 1 taken 407140 times.
✓ Branch 2 taken 1135689 times.
✓ Branch 3 taken 237974 times.
 1780803 while (!got_packet && !fci->parse_queue.head) {
1396 AVStream *st;
1397 FFStream *sti;
1398
1399 /* read next packet */
1400 1135689 ret = ff_read_packet(s, pkt);
1401
2/2
✓ Branch 0 taken 7137 times.
✓ Branch 1 taken 1128552 times.
 1135689 if (ret < 0) {
1402
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 7136 times.
 7137 if (ret == AVERROR(EAGAIN))
1403 1 return ret;
1404 /* flush the parsers */
1405
2/2
✓ Branch 0 taken 8328 times.
✓ Branch 1 taken 7136 times.
 15464 for (unsigned i = 0; i < s->nb_streams; i++) {
1406 8328 AVStream *const st = s->streams[i];
1407 8328 FFStream *const sti = ffstream(st);
1408
4/4
✓ Branch 0 taken 3198 times.
✓ Branch 1 taken 5130 times.
✓ Branch 2 taken 2335 times.
✓ Branch 3 taken 863 times.
 8328 if (sti->parser && sti->need_parsing)
1409 2335 parse_packet(s, pkt, st->index, 1);
1410 }
1411 /* all remaining packets are now in parse_queue =>
1412 * really terminate parsing */
1413 7136 break;
1414 }
1415 1128552 ret = 0;
1416 1128552 st = s->streams[pkt->stream_index];
1417 1128552 sti = ffstream(st);
1418
1419 1128552 st->event_flags |= AVSTREAM_EVENT_FLAG_NEW_PACKETS;
1420
1421 1128552 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 21 times.
✓ Branch 1 taken 1128531 times.
 1128552 if (new_extradata)
1424 21 sti->need_context_update = 1;
1425
1426 /* update context if required */
1427
2/2
✓ Branch 0 taken 191 times.
✓ Branch 1 taken 1128361 times.
 1128552 if (sti->need_context_update) {
1428
2/2
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 176 times.
 191 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 28 times.
✓ Branch 1 taken 163 times.
 191 if (sti->parser &&
1438
4/4
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 3 times.
 28 (sti->avctx->codec_id != st->codecpar->codec_id || new_extradata)) {
1439 25 av_parser_close(sti->parser);
1440 25 sti->parser = NULL;
1441 }
1442
1443 191 ret = avcodec_parameters_to_context(sti->avctx, st->codecpar);
1444
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 191 times.
 191 if (ret < 0) {
1445 ✗ av_packet_unref(pkt);
1446 ✗ return ret;
1447 }
1448
1449
2/2
✓ Branch 0 taken 147 times.
✓ Branch 1 taken 44 times.
 191 if (!sti->avctx->extradata) {
1450 147 sti->extract_extradata.inited = 0;
1451
1452 147 ret = extract_extradata(si, st, pkt);
1453
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 147 times.
 147 if (ret < 0) {
1454 ✗ av_packet_unref(pkt);
1455 ✗ return ret;
1456 }
1457 }
1458
1459 191 sti->codec_desc = avcodec_descriptor_get(sti->avctx->codec_id);
1460
1461 191 sti->need_context_update = 0;
1462 }
1463
1464
2/2
✓ Branch 0 taken 349052 times.
✓ Branch 1 taken 779500 times.
 1128552 if (pkt->pts != AV_NOPTS_VALUE &&
1465
2/2
✓ Branch 0 taken 173009 times.
✓ Branch 1 taken 176043 times.
 349052 pkt->dts != AV_NOPTS_VALUE &&
1466
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 173009 times.
 173009 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 1128552 times.
 1128552 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 722658 times.
✓ Branch 1 taken 405894 times.
✓ Branch 2 taken 2946 times.
✓ Branch 3 taken 719712 times.
✓ Branch 4 taken 2946 times.
✗ Branch 5 not taken.
 1128552 if (sti->need_parsing && !sti->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1483 2946 sti->parser = av_parser_init(st->codecpar->codec_id);
1484
2/2
✓ Branch 0 taken 1246 times.
✓ Branch 1 taken 1700 times.
 2946 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 726 times.
✓ Branch 1 taken 974 times.
 1700 } else if (sti->need_parsing == AVSTREAM_PARSE_HEADERS)
1491 726 sti->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1492
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 974 times.
 974 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 496 times.
 974 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 721412 times.
✓ Branch 1 taken 407140 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 721412 times.
 1128552 if (!sti->need_parsing || !sti->parser) {
1499 /* no parsing needed: we just output the packet as is */
1500 407140 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1501
2/2
✓ Branch 0 taken 99359 times.
✓ Branch 1 taken 307781 times.
 407140 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1502
4/4
✓ Branch 0 taken 98495 times.
✓ Branch 1 taken 864 times.
✓ Branch 2 taken 98221 times.
✓ Branch 3 taken 274 times.
 99359 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1503 98221 ff_reduce_index(s, st->index);
1504 98221 av_add_index_entry(st, pkt->pos, pkt->dts,
1505 0, 0, AVINDEX_KEYFRAME);
1506 }
1507 407140 got_packet = 1;
1508
2/2
✓ Branch 0 taken 721279 times.
✓ Branch 1 taken 133 times.
 721412 } else if (st->discard < AVDISCARD_ALL) {
1509
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 721279 times.
 721279 if ((ret = parse_packet(s, pkt, pkt->stream_index, 0)) < 0)
1510 ✗ return ret;
1511 721279 st->codecpar->sample_rate = sti->avctx->sample_rate;
1512 721279 st->codecpar->bit_rate = sti->avctx->bit_rate;
1513 721279 ret = av_channel_layout_copy(&st->codecpar->ch_layout, &sti->avctx->ch_layout);
1514
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 721279 times.
 721279 if (ret < 0)
1515 ✗ return ret;
1516 721279 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 380910 times.
✓ Branch 1 taken 747642 times.
 1128552 if (pkt->flags & AV_PKT_FLAG_KEY)
1522 380910 sti->skip_to_keyframe = 0;
1523
2/2
✓ Branch 0 taken 85 times.
✓ Branch 1 taken 1128467 times.
 1128552 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 245110 times.
✓ Branch 1 taken 407140 times.
✓ Branch 2 taken 238988 times.
✓ Branch 3 taken 6122 times.
 652250 if (!got_packet && fci->parse_queue.head)
1530 238988 ret = ff_packet_list_get(&fci->parse_queue, pkt);
1531
1532
2/2
✓ Branch 0 taken 646128 times.
✓ Branch 1 taken 6122 times.
 652250 if (ret >= 0) {
1533 646128 AVStream *const st = s->streams[pkt->stream_index];
1534 646128 FFStream *const sti = ffstream(st);
1535 646128 int discard_padding = 0;
1536
3/4
✓ Branch 0 taken 16462 times.
✓ Branch 1 taken 629666 times.
✓ Branch 2 taken 16462 times.
✗ Branch 3 not taken.
 646128 if (sti->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1537
2/2
✓ Branch 1 taken 6932 times.
✓ Branch 2 taken 9530 times.
 16462 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1538 16462 int64_t sample = ts_to_samples(st, pts);
1539
2/2
✓ Branch 1 taken 17 times.
✓ Branch 2 taken 16445 times.
 16462 int64_t duration = FFMAX(st->codecpar->frame_size, ts_to_samples(st, pkt->duration));
1540 16462 int64_t end_sample = sample + duration;
1541
3/4
✓ Branch 0 taken 16462 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 330 times.
✓ Branch 3 taken 16132 times.
 16462 if (duration > 0 && end_sample >= sti->first_discard_sample &&
1542
2/2
✓ Branch 0 taken 326 times.
✓ Branch 1 taken 4 times.
 330 sample < sti->last_discard_sample)
1543 326 discard_padding = FFMIN(end_sample - sti->first_discard_sample, duration);
1544 }
1545
6/6
✓ Branch 0 taken 9598 times.
✓ Branch 1 taken 636530 times.
✓ Branch 2 taken 9580 times.
✓ Branch 3 taken 18 times.
✓ Branch 4 taken 126 times.
✓ Branch 5 taken 9454 times.
 646128 if (sti->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
1546 144 sti->skip_samples = sti->start_skip_samples;
1547 646128 sti->skip_samples = FFMAX(0, sti->skip_samples);
1548
4/4
✓ Branch 0 taken 645878 times.
✓ Branch 1 taken 250 times.
✓ Branch 2 taken 127 times.
✓ Branch 3 taken 645751 times.
 646128 if (sti->skip_samples || discard_padding) {
1549 377 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1550
1/2
✓ Branch 0 taken 377 times.
✗ Branch 1 not taken.
 377 if (p) {
1551 377 AV_WL32(p, sti->skip_samples);
1552 377 AV_WL32(p + 4, discard_padding);
1553 377 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %u / discard %u\n",
1554 377 (unsigned)sti->skip_samples, (unsigned)discard_padding);
1555 }
1556 377 sti->skip_samples = 0;
1557 }
1558 }
1559
1560
2/2
✓ Branch 0 taken 8253 times.
✓ Branch 1 taken 643997 times.
 652250 if (!fci->metafree) {
1561 8253 int metaret = av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1562
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8253 times.
 8253 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 8253 fci->metafree = metaret == AVERROR_OPTION_NOT_FOUND;
1569 }
1570
1571
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 652250 times.
 652250 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 6012 times.
✓ Branch 1 taken 646238 times.
✓ Branch 2 taken 5764 times.
✓ Branch 3 taken 248 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5764 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 652250 if (ret == AVERROR_EOF && s->pb && s->pb->error < 0 && s->pb->error != AVERROR(EAGAIN))
1583 ✗ ret = s->pb->error;
1584
1585 652250 return ret;
1586 }
1587
1588 549690 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1589 {
1590 549690 FFFormatContext *const si = ffformatcontext(s);
1591 549690 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1592 549690 int eof = 0;
1593 int ret;
1594 AVStream *st;
1595
1596
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 549690 times.
 549690 if (!genpts) {
1597 1099380 ret = si->packet_buffer.head
1598 101259 ? ff_packet_list_get(&si->packet_buffer, pkt)
1599
2/2
✓ Branch 0 taken 101259 times.
✓ Branch 1 taken 448431 times.
 549690 : read_frame_internal(s, pkt);
1600
2/2
✓ Branch 0 taken 4716 times.
✓ Branch 1 taken 544974 times.
 549690 if (ret < 0)
1601 4716 return ret;
1602 544974 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 544974 return_packet:
1669 544974 st = s->streams[pkt->stream_index];
1670
4/4
✓ Branch 0 taken 244506 times.
✓ Branch 1 taken 300468 times.
✓ Branch 2 taken 169444 times.
✓ Branch 3 taken 75062 times.
 544974 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1671 169444 ff_reduce_index(s, st->index);
1672 169444 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1673 }
1674
1675
2/2
✓ Branch 1 taken 160251 times.
✓ Branch 2 taken 384723 times.
 544974 if (is_relative(pkt->dts))
1676 160251 pkt->dts -= RELATIVE_TS_BASE;
1677
2/2
✓ Branch 1 taken 158557 times.
✓ Branch 2 taken 386417 times.
 544974 if (is_relative(pkt->pts))
1678 158557 pkt->pts -= RELATIVE_TS_BASE;
1679
1680 544974 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 8163 static int has_duration(AVFormatContext *ic)
1689 {
1690
2/2
✓ Branch 0 taken 8587 times.
✓ Branch 1 taken 2687 times.
 11274 for (unsigned i = 0; i < ic->nb_streams; i++) {
1691 8587 const AVStream *const st = ic->streams[i];
1692
2/2
✓ Branch 0 taken 5476 times.
✓ Branch 1 taken 3111 times.
 8587 if (st->duration != AV_NOPTS_VALUE)
1693 5476 return 1;
1694 }
1695
2/2
✓ Branch 0 taken 523 times.
✓ Branch 1 taken 2164 times.
 2687 if (ic->duration != AV_NOPTS_VALUE)
1696 523 return 1;
1697 2164 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 14352 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 14352 start_time = INT64_MAX;
1711 14352 start_time_text = INT64_MAX;
1712 14352 end_time = INT64_MIN;
1713 14352 end_time_text = INT64_MIN;
1714 14352 duration = INT64_MIN;
1715 14352 duration_text = INT64_MIN;
1716
1717
2/2
✓ Branch 0 taken 16102 times.
✓ Branch 1 taken 14352 times.
 30454 for (unsigned i = 0; i < ic->nb_streams; i++) {
1718 16102 AVStream *const st = ic->streams[i];
1719
2/2
✓ Branch 0 taken 15961 times.
✓ Branch 1 taken 141 times.
 32063 int is_text = st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ||
1720
2/2
✓ Branch 0 taken 183 times.
✓ Branch 1 taken 15778 times.
 15961 st->codecpar->codec_type == AVMEDIA_TYPE_DATA;
1721
1722
3/4
✓ Branch 0 taken 13097 times.
✓ Branch 1 taken 3005 times.
✓ Branch 2 taken 13097 times.
✗ Branch 3 not taken.
 16102 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1723 13097 start_time1 = av_rescale_q(st->start_time, st->time_base,
1724 13097 AV_TIME_BASE_Q);
1725
2/2
✓ Branch 0 taken 188 times.
✓ Branch 1 taken 12909 times.
 13097 if (is_text)
1726 188 start_time_text = FFMIN(start_time_text, start_time1);
1727 else
1728 12909 start_time = FFMIN(start_time, start_time1);
1729 13097 end_time1 = av_rescale_q_rnd(st->duration, st->time_base,
1730 13097 AV_TIME_BASE_Q,
1731 AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
1732
5/6
✓ Branch 0 taken 11518 times.
✓ Branch 1 taken 1579 times.
✓ Branch 2 taken 11489 times.
✓ Branch 3 taken 29 times.
✓ Branch 4 taken 11518 times.
✗ Branch 5 not taken.
 13097 if (end_time1 != AV_NOPTS_VALUE && (end_time1 > 0 ? start_time1 <= INT64_MAX - end_time1 : start_time1 >= INT64_MIN - end_time1)) {
1733 11518 end_time1 += start_time1;
1734
2/2
✓ Branch 0 taken 171 times.
✓ Branch 1 taken 11347 times.
 11518 if (is_text)
1735 171 end_time_text = FFMAX(end_time_text, end_time1);
1736 else
1737 11347 end_time = FFMAX(end_time, end_time1);
1738 }
1739
2/2
✓ Branch 1 taken 281 times.
✓ Branch 2 taken 13097 times.
 13378 for (AVProgram *p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
1740
4/4
✓ Branch 0 taken 197 times.
✓ Branch 1 taken 84 times.
✓ Branch 2 taken 27 times.
✓ Branch 3 taken 170 times.
 281 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
1741 111 p->start_time = start_time1;
1742
2/2
✓ Branch 0 taken 75 times.
✓ Branch 1 taken 206 times.
 281 if (p->end_time < end_time1)
1743 75 p->end_time = end_time1;
1744 }
1745 }
1746
2/2
✓ Branch 0 taken 13186 times.
✓ Branch 1 taken 2916 times.
 16102 if (st->duration != AV_NOPTS_VALUE) {
1747 13186 duration1 = av_rescale_q(st->duration, st->time_base,
1748 13186 AV_TIME_BASE_Q);
1749
2/2
✓ Branch 0 taken 201 times.
✓ Branch 1 taken 12985 times.
 13186 if (is_text)
1750 201 duration_text = FFMAX(duration_text, duration1);
1751 else
1752 12985 duration = FFMAX(duration, duration1);
1753 }
1754 }
1755
3/6
✓ Branch 0 taken 11687 times.
✓ Branch 1 taken 2665 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11687 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 14352 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - (uint64_t)start_time_text < AV_TIME_BASE))
1756 2665 start_time = start_time_text;
1757
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11687 times.
 11687 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 10566 times.
✓ Branch 1 taken 3786 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 10560 times.
✓ Branch 4 taken 4 times.
✓ Branch 5 taken 2 times.
 14352 if (end_time == INT64_MIN || (end_time < end_time_text && end_time_text - (uint64_t)end_time < AV_TIME_BASE))
1761 3790 end_time = end_time_text;
1762
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 10560 times.
 10562 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 12111 times.
✓ Branch 1 taken 2241 times.
✓ Branch 2 taken 14 times.
✓ Branch 3 taken 12097 times.
✓ Branch 4 taken 12 times.
✓ Branch 5 taken 2 times.
 14352 if (duration == INT64_MIN || (duration < duration_text && (uint64_t)duration_text - duration < AV_TIME_BASE))
1766 2253 duration = duration_text;
1767
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 12097 times.
 12099 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 11710 times.
✓ Branch 1 taken 2642 times.
 14352 if (start_time != INT64_MAX) {
1771 11710 ic->start_time = start_time;
1772
2/2
✓ Branch 0 taken 10583 times.
✓ Branch 1 taken 1127 times.
 11710 if (end_time != INT64_MIN) {
1773
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10583 times.
 10583 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 10583 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 10583 times.
✗ Branch 3 not taken.
 10583 } else if (end_time >= start_time && end_time - (uint64_t)start_time <= INT64_MAX) {
1783 10583 duration = FFMAX(duration, end_time - start_time);
1784 }
1785 }
1786 }
1787
6/6
✓ Branch 0 taken 12141 times.
✓ Branch 1 taken 2211 times.
✓ Branch 2 taken 12105 times.
✓ Branch 3 taken 36 times.
✓ Branch 4 taken 6477 times.
✓ Branch 5 taken 5628 times.
 14352 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
1788 6477 ic->duration = duration;
1789 }
1790
6/6
✓ Branch 0 taken 8032 times.
✓ Branch 1 taken 6320 times.
✓ Branch 3 taken 8031 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 6832 times.
✓ Branch 6 taken 1199 times.
 14352 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration > 0) {
1791 /* compute the bitrate */
1792 6832 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
1793 6832 (double) ic->duration;
1794
2/4
✓ Branch 0 taken 6832 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6832 times.
✗ Branch 3 not taken.
 6832 if (bitrate >= 0 && bitrate <= INT64_MAX)
1795 6832 ic->bit_rate = bitrate;
1796 }
1797 14352 }
1798
1799 6094 static void fill_all_stream_timings(AVFormatContext *ic)
1800 {
1801 6094 update_stream_timings(ic);
1802
2/2
✓ Branch 0 taken 6839 times.
✓ Branch 1 taken 6094 times.
 12933 for (unsigned i = 0; i < ic->nb_streams; i++) {
1803 6839 AVStream *const st = ic->streams[i];
1804
1805
2/2
✓ Branch 0 taken 866 times.
✓ Branch 1 taken 5973 times.
 6839 if (st->start_time == AV_NOPTS_VALUE) {
1806
2/2
✓ Branch 0 taken 157 times.
✓ Branch 1 taken 709 times.
 866 if (ic->start_time != AV_NOPTS_VALUE)
1807 157 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
1808 st->time_base);
1809
2/2
✓ Branch 0 taken 851 times.
✓ Branch 1 taken 15 times.
 866 if (ic->duration != AV_NOPTS_VALUE)
1810 851 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
1811 st->time_base);
1812 }
1813 }
1814 6094 }
1815
1816 2164 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1817 {
1818 2164 FFFormatContext *const si = ffformatcontext(ic);
1819 2164 int show_warning = 0;
1820
1821 /* if bit_rate is already set, we believe it */
1822
2/2
✓ Branch 0 taken 2129 times.
✓ Branch 1 taken 35 times.
 2164 if (ic->bit_rate <= 0) {
1823 2129 int64_t bit_rate = 0;
1824
2/2
✓ Branch 0 taken 2365 times.
✓ Branch 1 taken 1452 times.
 3817 for (unsigned i = 0; i < ic->nb_streams; i++) {
1825 2365 const AVStream *const st = ic->streams[i];
1826 2365 const FFStream *const sti = cffstream(st);
1827
4/4
✓ Branch 0 taken 1530 times.
✓ Branch 1 taken 835 times.
✓ Branch 2 taken 200 times.
✓ Branch 3 taken 1330 times.
 2365 if (st->codecpar->bit_rate <= 0 && sti->avctx->bit_rate > 0)
1828 200 st->codecpar->bit_rate = sti->avctx->bit_rate;
1829
2/2
✓ Branch 0 taken 1035 times.
✓ Branch 1 taken 1330 times.
 2365 if (st->codecpar->bit_rate > 0) {
1830
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1035 times.
 1035 if (INT64_MAX - st->codecpar->bit_rate < bit_rate) {
1831 ✗ bit_rate = 0;
1832 ✗ break;
1833 }
1834 1035 bit_rate += st->codecpar->bit_rate;
1835
4/4
✓ Branch 0 taken 1112 times.
✓ Branch 1 taken 218 times.
✓ Branch 2 taken 677 times.
✓ Branch 3 taken 435 times.
 1330 } 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 677 bit_rate = 0;
1839 677 break;
1840 }
1841 }
1842 2129 ic->bit_rate = bit_rate;
1843 }
1844
1845 /* if duration is already set, we believe it */
1846
1/2
✓ Branch 0 taken 2164 times.
✗ Branch 1 not taken.
 2164 if (ic->duration == AV_NOPTS_VALUE &&
1847
2/2
✓ Branch 0 taken 967 times.
✓ Branch 1 taken 1197 times.
 2164 ic->bit_rate != 0) {
1848
2/2
✓ Branch 0 taken 933 times.
✓ Branch 1 taken 34 times.
 967 int64_t filesize = ic->pb ? avio_size(ic->pb) : 0;
1849
2/2
✓ Branch 0 taken 924 times.
✓ Branch 1 taken 43 times.
 967 if (filesize > si->data_offset) {
1850 924 filesize -= si->data_offset;
1851
2/2
✓ Branch 0 taken 1038 times.
✓ Branch 1 taken 924 times.
 1962 for (unsigned i = 0; i < ic->nb_streams; i++) {
1852 1038 AVStream *const st = ic->streams[i];
1853
1854
1/2
✓ Branch 0 taken 1038 times.
✗ Branch 1 not taken.
 1038 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
1855
1/2
✓ Branch 0 taken 1038 times.
✗ Branch 1 not taken.
 1038 && st->duration == AV_NOPTS_VALUE) {
1856 1038 st->duration = av_rescale(filesize, 8LL * st->time_base.den,
1857 1038 ic->bit_rate *
1858 1038 (int64_t) st->time_base.num);
1859 1038 show_warning = 1;
1860 }
1861 }
1862 }
1863 }
1864
2/2
✓ Branch 0 taken 924 times.
✓ Branch 1 taken 1240 times.
 2164 if (show_warning)
1865 924 av_log(ic, AV_LOG_WARNING,
1866 "Estimating duration from bitrate, this may be inaccurate\n");
1867 2164 }
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 95 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1875 {
1876 95 FFFormatContext *const si = ffformatcontext(ic);
1877 95 AVPacket *const pkt = si->pkt;
1878 int num, den, read_size, ret;
1879
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 95 times.
 95 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 95 times.
 95 int duration_max_retry = ic->duration_probesize ? DURATION_MAX_RETRY : DURATION_DEFAULT_MAX_RETRY;
1881 95 int found_duration = 0;
1882 int is_end;
1883 int64_t filesize, offset, duration;
1884 95 int retry = 0;
1885
1886 /* flush packet queue */
1887 95 ff_flush_packet_queue(ic);
1888
1889
2/2
✓ Branch 0 taken 179 times.
✓ Branch 1 taken 95 times.
 274 for (unsigned i = 0; i < ic->nb_streams; i++) {
1890 179 AVStream *const st = ic->streams[i];
1891 179 FFStream *const sti = ffstream(st);
1892
1893
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 155 times.
 179 if (st->start_time == AV_NOPTS_VALUE &&
1894
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 sti->first_dts == AV_NOPTS_VALUE &&
1895
1/2
✓ Branch 0 taken 24 times.
✗ Branch 1 not taken.
 24 st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN)
1896 24 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 154 times.
 179 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 95 times.
 95 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 95 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 95 times.
✗ Branch 1 not taken.
 95 filesize = ic->pb ? avio_size(ic->pb) : 0;
1914 do {
1915 102 is_end = found_duration;
1916 102 offset = filesize - (duration_max_read_size << retry);
1917
2/2
✓ Branch 0 taken 46 times.
✓ Branch 1 taken 56 times.
 102 if (offset < 0)
1918 46 offset = 0;
1919
1920 102 avio_seek(ic->pb, offset, SEEK_SET);
1921 102 read_size = 0;
1922 8138 for (;;) {
1923 AVStream *st;
1924 FFStream *sti;
1925
2/2
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 8233 times.
 8240 if (read_size >= duration_max_read_size << (FFMAX(retry - 1, 0)))
1926 7 break;
1927
1928 do {
1929 8233 ret = ff_read_packet(ic, pkt);
1930
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8233 times.
 8233 } while (ret == AVERROR(EAGAIN));
1931
2/2
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 8138 times.
 8233 if (ret != 0)
1932 95 break;
1933 8138 read_size += pkt->size;
1934 8138 st = ic->streams[pkt->stream_index];
1935 8138 sti = ffstream(st);
1936
2/2
✓ Branch 0 taken 4035 times.
✓ Branch 1 taken 4103 times.
 8138 if (pkt->pts != AV_NOPTS_VALUE &&
1937
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4035 times.
 4035 (st->start_time != AV_NOPTS_VALUE ||
1938 ✗ sti->first_dts != AV_NOPTS_VALUE)) {
1939
1/2
✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
 4035 if (pkt->duration == 0) {
1940 4035 compute_frame_duration(ic, &num, &den, st, sti->parser, pkt);
1941
3/4
✓ Branch 0 taken 3551 times.
✓ Branch 1 taken 484 times.
✓ Branch 2 taken 3551 times.
✗ Branch 3 not taken.
 4035 if (den && num) {
1942 3551 pkt->duration = av_rescale_rnd(1,
1943 3551 num * (int64_t) st->time_base.den,
1944 3551 den * (int64_t) st->time_base.num,
1945 AV_ROUND_DOWN);
1946 }
1947 }
1948 4035 duration = pkt->pts + pkt->duration;
1949 4035 found_duration = 1;
1950
1/2
✓ Branch 0 taken 4035 times.
✗ Branch 1 not taken.
 4035 if (st->start_time != AV_NOPTS_VALUE)
1951 4035 duration -= st->start_time;
1952 else
1953 ✗ duration -= sti->first_dts;
1954
2/2
✓ Branch 0 taken 4023 times.
✓ Branch 1 taken 12 times.
 4035 if (duration > 0) {
1955
3/4
✓ Branch 0 taken 3878 times.
✓ Branch 1 taken 145 times.
✓ Branch 2 taken 3878 times.
✗ Branch 3 not taken.
 4023 if (st->duration == AV_NOPTS_VALUE || sti->info->last_duration<= 0 ||
1956
3/4
✓ Branch 0 taken 3136 times.
✓ Branch 1 taken 742 times.
✓ Branch 2 taken 3136 times.
✗ Branch 3 not taken.
 3878 (st->duration < duration && FFABS(duration - sti->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
1957 3281 st->duration = duration;
1958 4023 sti->info->last_duration = duration;
1959 }
1960 }
1961 8138 av_packet_unref(pkt);
1962 }
1963
1964 /* check if all audio/video streams have valid duration */
1965
2/2
✓ Branch 0 taken 95 times.
✓ Branch 1 taken 7 times.
 102 if (!is_end) {
1966 95 is_end = 1;
1967
2/2
✓ Branch 0 taken 179 times.
✓ Branch 1 taken 95 times.
 274 for (unsigned i = 0; i < ic->nb_streams; i++) {
1968 179 const AVStream *const st = ic->streams[i];
1969
2/2
✓ Branch 0 taken 159 times.
✓ Branch 1 taken 20 times.
 179 switch (st->codecpar->codec_type) {
1970 159 case AVMEDIA_TYPE_VIDEO:
1971 case AVMEDIA_TYPE_AUDIO:
1972
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 135 times.
 159 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 93 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
 109 offset &&
1979 ++retry <= duration_max_retry);
1980
1981 95 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 179 times.
✓ Branch 1 taken 95 times.
 274 for (unsigned i = 0; i < ic->nb_streams; i++) {
1985 179 const AVStream *const st = ic->streams[i];
1986 179 const FFStream *const sti = cffstream(st);
1987
1988
2/2
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 145 times.
 179 if (st->duration == AV_NOPTS_VALUE) {
1989
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 17 times.
 34 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 95 skip_duration_calc:
2000 95 fill_all_stream_timings(ic);
2001
2002 95 avio_seek(ic->pb, old_offset, SEEK_SET);
2003
2/2
✓ Branch 0 taken 179 times.
✓ Branch 1 taken 95 times.
 274 for (unsigned i = 0; i < ic->nb_streams; i++) {
2004 179 AVStream *const st = ic->streams[i];
2005 179 FFStream *const sti = ffstream(st);
2006
2007 179 sti->cur_dts = sti->first_dts;
2008 179 sti->last_IP_pts = AV_NOPTS_VALUE;
2009 179 sti->last_dts_for_order_check = AV_NOPTS_VALUE;
2010
2/2
✓ Branch 0 taken 3043 times.
✓ Branch 1 taken 179 times.
 3222 for (int j = 0; j < MAX_REORDER_DELAY + 1; j++)
2011 3043 sti->pts_buffer[j] = AV_NOPTS_VALUE;
2012 }
2013 95 }
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 8258 static const char *duration_estimate_name(enum AVDurationEstimationMethod method)
2023 {
2024 8258 return duration_name[method];
2025 }
2026
2027 8258 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 3225 times.
✓ Branch 1 taken 5033 times.
 8258 if (ic->iformat->flags & AVFMT_NOFILE) {
2033 3225 file_size = 0;
2034 } else {
2035 5033 file_size = avio_size(ic->pb);
2036 5033 file_size = FFMAX(0, file_size);
2037 }
2038
2039
2/2
✓ Branch 0 taken 8230 times.
✓ Branch 1 taken 28 times.
 8258 if ((!strcmp(ic->iformat->name, "mpeg") ||
2040
4/4
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 8162 times.
✓ Branch 2 taken 95 times.
✓ Branch 3 taken 1 times.
 8258 !strcmp(ic->iformat->name, "mpegts")) &&
2041
1/2
✓ Branch 0 taken 95 times.
✗ Branch 1 not taken.
 95 file_size && (ic->pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2042 /* get accurate estimate from the PTSes */
2043 95 estimate_timings_from_pts(ic, old_offset);
2044 95 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2045
2/2
✓ Branch 1 taken 5999 times.
✓ Branch 2 taken 2164 times.
 8163 } else if (has_duration(ic)) {
2046 /* at least one component has timings - we use them for all
2047 * the components */
2048 5999 fill_all_stream_timings(ic);
2049 /* nut demuxer estimate the duration from PTS */
2050
2/2
✓ Branch 0 taken 69 times.
✓ Branch 1 taken 5930 times.
 5999 if (!strcmp(ic->iformat->name, "nut"))
2051 69 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2052 else
2053 5930 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2054 } else {
2055 /* less precise: use bitrate info */
2056 2164 estimate_timings_from_bit_rate(ic);
2057 2164 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2058 }
2059 8258 update_stream_timings(ic);
2060
2061
2/2
✓ Branch 0 taken 9263 times.
✓ Branch 1 taken 8258 times.
 17521 for (unsigned i = 0; i < ic->nb_streams; i++) {
2062 9263 AVStream *const st = ic->streams[i];
2063
1/2
✓ Branch 0 taken 9263 times.
✗ Branch 1 not taken.
 9263 if (st->time_base.den)
2064 9263 av_log(ic, AV_LOG_TRACE, "stream %u: start_time: %s duration: %s\n", i,
2065 9263 av_ts2timestr(st->start_time, &st->time_base),
2066 9263 av_ts2timestr(st->duration, &st->time_base));
2067 }
2068 8258 av_log(ic, AV_LOG_TRACE,
2069 "format: start_time: %s duration: %s (estimate from %s) bitrate=%"PRId64" kb/s\n",
2070 8258 av_ts2timestr(ic->start_time, &AV_TIME_BASE_Q),
2071 8258 av_ts2timestr(ic->duration, &AV_TIME_BASE_Q),
2072 duration_estimate_name(ic->duration_estimation_method),
2073 8258 (int64_t)ic->bit_rate / 1000);
2074 8258 }
2075
2076 107787 static int determinable_frame_size(const AVCodecContext *avctx)
2077 {
2078
2/2
✓ Branch 0 taken 415 times.
✓ Branch 1 taken 107372 times.
 107787 switch(avctx->codec_id) {
2079 415 case AV_CODEC_ID_MP1:
2080 case AV_CODEC_ID_MP2:
2081 case AV_CODEC_ID_MP3:
2082 case AV_CODEC_ID_CODEC2:
2083 415 return 1;
2084 }
2085
2086 107372 return 0;
2087 }
2088
2089 446859 static int has_codec_parameters(const AVStream *st, const char **errmsg_ptr)
2090 {
2091 446859 const FFStream *const sti = cffstream(st);
2092 446859 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 762 times.
✓ Branch 1 taken 446097 times.
 446859 if ( avctx->codec_id == AV_CODEC_ID_NONE
2101
2/2
✓ Branch 0 taken 513 times.
✓ Branch 1 taken 249 times.
 762 && 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 130536 times.
✓ Branch 1 taken 314121 times.
✓ Branch 2 taken 665 times.
✓ Branch 3 taken 1024 times.
✗ Branch 4 not taken.
 446346 switch (avctx->codec_type) {
2104 130536 case AVMEDIA_TYPE_AUDIO:
2105
4/4
✓ Branch 0 taken 107787 times.
✓ Branch 1 taken 22749 times.
✓ Branch 3 taken 415 times.
✓ Branch 4 taken 107372 times.
 130536 if (!avctx->frame_size && determinable_frame_size(avctx))
2106
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 413 times.
 415 FAIL("unspecified frame size");
2107
1/2
✓ Branch 0 taken 130121 times.
✗ Branch 1 not taken.
 130121 if (sti->info->found_decoder >= 0 &&
2108
2/2
✓ Branch 0 taken 2951 times.
✓ Branch 1 taken 127170 times.
 130121 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2109
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2950 times.
 2951 FAIL("unspecified sample format");
2110
2/2
✓ Branch 0 taken 194 times.
✓ Branch 1 taken 126976 times.
 127170 if (!avctx->sample_rate)
2111
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 188 times.
 194 FAIL("unspecified sample rate");
2112
2/2
✓ Branch 0 taken 22 times.
✓ Branch 1 taken 126954 times.
 126976 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 126954 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 81945 times.
✓ Branch 3 taken 45009 times.
✓ Branch 4 taken 110 times.
✓ Branch 5 taken 81835 times.
 126954 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 126844 break;
2117 314121 case AVMEDIA_TYPE_VIDEO:
2118
2/2
✓ Branch 0 taken 13390 times.
✓ Branch 1 taken 300731 times.
 314121 if (!avctx->width)
2119
2/2
✓ Branch 0 taken 12 times.
✓ Branch 1 taken 13378 times.
 13390 FAIL("unspecified size");
2120
4/4
✓ Branch 0 taken 300459 times.
✓ Branch 1 taken 272 times.
✓ Branch 2 taken 4643 times.
✓ Branch 3 taken 295816 times.
 300731 if (sti->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2121
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 4640 times.
 4643 FAIL("unspecified pixel format");
2122
4/4
✓ Branch 0 taken 295988 times.
✓ Branch 1 taken 100 times.
✓ Branch 2 taken 86 times.
✓ Branch 3 taken 295902 times.
 296088 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 296021 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 1024 case AVMEDIA_TYPE_DATA:
2131
2/2
✓ Branch 0 taken 249 times.
✓ Branch 1 taken 775 times.
 1024 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2132 }
2133
2134 424284 return 1;
2135 }
2136
2137 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2138 207217 static int try_decode_frame(AVFormatContext *s, AVStream *st,
2139 const AVPacket *pkt, AVDictionary **options)
2140 {
2141 207217 FFStream *const sti = ffstream(st);
2142 207217 AVCodecContext *const avctx = sti->avctx;
2143 const AVCodec *codec;
2144 207217 int got_picture = 1, ret = 0;
2145 207217 AVFrame *frame = av_frame_alloc();
2146 AVSubtitle subtitle;
2147 207217 int do_skip_frame = 0;
2148 enum AVDiscard skip_frame;
2149 207217 int pkt_to_send = pkt->size > 0;
2150
2151
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 207217 times.
 207217 if (!frame)
2152 ✗ return AVERROR(ENOMEM);
2153
2154
2/2
✓ Branch 1 taken 1789 times.
✓ Branch 2 taken 205428 times.
 207217 if (!avcodec_is_open(avctx) &&
2155
1/2
✓ Branch 0 taken 1789 times.
✗ Branch 1 not taken.
 1789 sti->info->found_decoder <= 0 &&
2156
4/4
✓ Branch 0 taken 277 times.
✓ Branch 1 taken 1512 times.
✓ Branch 2 taken 57 times.
✓ Branch 3 taken 220 times.
 1789 (st->codecpar->codec_id != -sti->info->found_decoder || !st->codecpar->codec_id)) {
2157 1569 AVDictionary *thread_opt = NULL;
2158
2159 1569 codec = find_probe_decoder(s, st, st->codecpar->codec_id);
2160
2161
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 1485 times.
 1569 if (!codec) {
2162 84 sti->info->found_decoder = -st->codecpar->codec_id;
2163 84 ret = -1;
2164 86 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 169 times.
✓ Branch 1 taken 1316 times.
 1485 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 169 times.
✓ Branch 1 taken 1316 times.
 1485 av_dict_set(options ? options : &thread_opt, "lowres", "0", 0);
2174
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1485 times.
 1485 if (s->codec_whitelist)
2175 ✗ av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2176
2/2
✓ Branch 0 taken 169 times.
✓ Branch 1 taken 1316 times.
 1485 ret = avcodec_open2(avctx, codec, options ? options : &thread_opt);
2177
2/2
✓ Branch 0 taken 169 times.
✓ Branch 1 taken 1316 times.
 1485 if (!options)
2178 169 av_dict_free(&thread_opt);
2179
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1483 times.
 1485 if (ret < 0) {
2180 2 sti->info->found_decoder = -avctx->codec_id;
2181 2 goto fail;
2182 }
2183 1483 sti->info->found_decoder = 1;
2184
2/2
✓ Branch 0 taken 7268 times.
✓ Branch 1 taken 198380 times.
 205648 } else if (!sti->info->found_decoder)
2185 7268 sti->info->found_decoder = 1;
2186
2187
2/2
✓ Branch 0 taken 220 times.
✓ Branch 1 taken 206911 times.
 207131 if (sti->info->found_decoder < 0) {
2188 220 ret = -1;
2189 220 goto fail;
2190 }
2191
2192
2/2
✓ Branch 1 taken 120271 times.
✓ Branch 2 taken 86640 times.
 206911 if (avpriv_codec_get_cap_skip_frame_fill_param(avctx->codec)) {
2193 120271 do_skip_frame = 1;
2194 120271 skip_frame = avctx->skip_frame;
2195 120271 avctx->skip_frame = AVDISCARD_ALL;
2196 }
2197
2198
5/6
✓ Branch 0 taken 8662 times.
✓ Branch 1 taken 4939 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 4909 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 206919 times.
 422522 while ((pkt_to_send || (!pkt->data && got_picture)) &&
2199
4/4
✓ Branch 0 taken 13601 times.
✓ Branch 1 taken 202010 times.
✓ Branch 2 taken 6050 times.
✓ Branch 3 taken 200869 times.
 422530 ret >= 0 &&
2200
2/2
✓ Branch 2 taken 2336 times.
✓ Branch 3 taken 198533 times.
 407788 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2201
2/2
✓ Branch 0 taken 195453 times.
✓ Branch 1 taken 3080 times.
 198533 (!sti->codec_info_nb_frames &&
2202
2/2
✓ Branch 0 taken 564 times.
✓ Branch 1 taken 2516 times.
 3080 (avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)))) {
2203 8950 got_picture = 0;
2204
2/2
✓ Branch 0 taken 1023 times.
✓ Branch 1 taken 7927 times.
 8950 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
2205
2/2
✓ Branch 0 taken 1016 times.
✓ Branch 1 taken 7 times.
 1023 avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2206 8943 ret = avcodec_send_packet(avctx, pkt);
2207
5/6
✓ Branch 0 taken 259 times.
✓ Branch 1 taken 8684 times.
✓ Branch 2 taken 259 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 250 times.
✓ Branch 5 taken 9 times.
 8943 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2208 250 break;
2209
2/2
✓ Branch 0 taken 8684 times.
✓ Branch 1 taken 9 times.
 8693 if (ret >= 0)
2210 8684 pkt_to_send = 0;
2211 8693 ret = avcodec_receive_frame(avctx, frame);
2212
2/2
✓ Branch 0 taken 3327 times.
✓ Branch 1 taken 5366 times.
 8693 if (ret >= 0)
2213 3327 got_picture = 1;
2214
4/4
✓ Branch 0 taken 3357 times.
✓ Branch 1 taken 5336 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 3327 times.
 8693 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
2215 5366 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 8700 times.
✗ Branch 1 not taken.
 8700 if (ret >= 0) {
2225
2/2
✓ Branch 0 taken 3329 times.
✓ Branch 1 taken 5371 times.
 8700 if (got_picture)
2226 3329 sti->nb_decoded_frames++;
2227 8700 ret = got_picture;
2228 }
2229 }
2230
2231 206661 fail:
2232
2/2
✓ Branch 0 taken 120271 times.
✓ Branch 1 taken 86946 times.
 207217 if (do_skip_frame) {
2233 120271 avctx->skip_frame = skip_frame;
2234 }
2235
2236 207217 av_frame_free(&frame);
2237 207217 return ret;
2238 }
2239
2240 89 static int chapter_start_cmp(const void *p1, const void *p2)
2241 {
2242 89 const AVChapter *const ch1 = *(AVChapter**)p1;
2243 89 const AVChapter *const ch2 = *(AVChapter**)p2;
2244 89 int delta = av_compare_ts(ch1->start, ch1->time_base, ch2->start, ch2->time_base);
2245
1/2
✓ Branch 0 taken 89 times.
✗ Branch 1 not taken.
 89 if (delta)
2246 89 return delta;
2247 ✗ return FFDIFFSIGN(ch1->id, ch2->id);
2248 }
2249
2250 8258 static int compute_chapters_end(AVFormatContext *s)
2251 {
2252 8258 int64_t max_time = 0;
2253 AVChapter **timetable;
2254
2255
2/2
✓ Branch 0 taken 8201 times.
✓ Branch 1 taken 57 times.
 8258 if (!s->nb_chapters)
2256 8201 return 0;
2257
2258
2/4
✓ Branch 0 taken 57 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 57 times.
✗ Branch 3 not taken.
 57 if (s->duration > 0 && s->start_time < INT64_MAX - s->duration)
2259 57 max_time = s->duration +
2260
2/2
✓ Branch 0 taken 34 times.
✓ Branch 1 taken 23 times.
 57 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2261
2262 57 timetable = av_memdup(s->chapters, s->nb_chapters * sizeof(*timetable));
2263
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57 times.
 57 if (!timetable)
2264 ✗ return AVERROR(ENOMEM);
2265 57 qsort(timetable, s->nb_chapters, sizeof(*timetable), chapter_start_cmp);
2266
2267
2/2
✓ Branch 0 taken 134 times.
✓ Branch 1 taken 57 times.
 191 for (unsigned i = 0; i < s->nb_chapters; i++)
2268
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 84 times.
 134 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 57 av_free(timetable);
2284 57 return 0;
2285 }
2286
2287 19875475 static int get_std_framerate(int i)
2288 {
2289
2/2
✓ Branch 0 taken 18053436 times.
✓ Branch 1 taken 1822039 times.
 19875475 if (i < 30*12)
2290 18053436 return (i + 1) * 1001;
2291 1822039 i -= 30*12;
2292
2293
2/2
✓ Branch 0 taken 1384352 times.
✓ Branch 1 taken 437687 times.
 1822039 if (i < 30)
2294 1384352 return (i + 31) * 1001 * 12;
2295 437687 i -= 30;
2296
2297
2/2
✓ Branch 0 taken 140300 times.
✓ Branch 1 taken 297387 times.
 437687 if (i < 3)
2298 140300 return ((const int[]) { 80, 120, 240})[i] * 1001 * 12;
2299
2300 297387 i -= 3;
2301
2302 297387 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 219336 static int tb_unreliable(AVFormatContext *ic, AVStream *st)
2312 {
2313 219336 FFStream *const sti = ffstream(st);
2314 219336 const AVCodecDescriptor *desc = sti->codec_desc;
2315 219336 AVCodecContext *c = sti->avctx;
2316
4/4
✓ Branch 0 taken 218777 times.
✓ Branch 1 taken 559 times.
✓ Branch 2 taken 22337 times.
✓ Branch 3 taken 196440 times.
 219336 AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
2317 219336 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 19696 times.
✓ Branch 1 taken 199640 times.
 219336 : (((ic->ctx_flags & AVFMTCTX_NOHEADER) ||
2320
2/2
✓ Branch 0 taken 48297 times.
✓ Branch 1 taken 31637 times.
 79934 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ? (AVRational){0, 1}
2321
2/2
✓ Branch 0 taken 79934 times.
✓ Branch 1 taken 119706 times.
 199640 : st->time_base);
2322
2323
2/2
✓ Branch 0 taken 26266 times.
✓ Branch 1 taken 193070 times.
 219336 if (time_base.den >= 101LL * time_base.num ||
2324
2/2
✓ Branch 0 taken 25750 times.
✓ Branch 1 taken 516 times.
 26266 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 25539 times.
✓ Branch 1 taken 211 times.
 25750 c->codec_tag == AV_RL32("mp4v") ||
2328
2/2
✓ Branch 0 taken 16012 times.
✓ Branch 1 taken 9527 times.
 25539 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2329
2/2
✓ Branch 0 taken 15482 times.
✓ Branch 1 taken 530 times.
 16012 c->codec_id == AV_CODEC_ID_GIF ||
2330
2/2
✓ Branch 0 taken 14138 times.
✓ Branch 1 taken 1344 times.
 15482 c->codec_id == AV_CODEC_ID_HEVC ||
2331
2/2
✓ Branch 0 taken 3862 times.
✓ Branch 1 taken 10276 times.
 14138 c->codec_id == AV_CODEC_ID_H264)
2332 209060 return 1;
2333 10276 return 0;
2334 }
2335
2336 149390 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2337 {
2338 149390 FFStream *const sti = ffstream(st);
2339 149390 FFStreamInfo *info = sti->info;
2340 149390 int64_t last = info->last_dts;
2341
2342
6/6
✓ Branch 0 taken 132484 times.
✓ Branch 1 taken 16906 times.
✓ Branch 2 taken 126044 times.
✓ Branch 3 taken 6440 times.
✓ Branch 4 taken 126017 times.
✓ Branch 5 taken 27 times.
 149390 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2343
1/2
✓ Branch 0 taken 126017 times.
✗ Branch 1 not taken.
 126017 && ts - (uint64_t)last < INT64_MAX) {
2344
2/2
✓ Branch 1 taken 6615 times.
✓ Branch 2 taken 119402 times.
 126017 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2345 126017 int64_t duration = ts - last;
2346
2347
2/2
✓ Branch 0 taken 4146 times.
✓ Branch 1 taken 121871 times.
 126017 if (!info->duration_error)
2348 4146 info->duration_error = av_mallocz(sizeof(info->duration_error[0])*2);
2349
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126017 times.
 126017 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 50280783 times.
✓ Branch 1 taken 126017 times.
 50406800 for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2355
2/2
✓ Branch 0 taken 19476124 times.
✓ Branch 1 taken 30804659 times.
 50280783 if (info->duration_error[0][1][i] < 1e10) {
2356 19476124 int framerate = get_std_framerate(i);
2357 19476124 double sdts = dts*framerate/(1001*12);
2358
2/2
✓ Branch 0 taken 38952248 times.
✓ Branch 1 taken 19476124 times.
 58428372 for (int j = 0; j < 2; j++) {
2359 38952248 int64_t ticks = llrint(sdts+j*0.5);
2360 38952248 double error = sdts - ticks + j*0.5;
2361 38952248 info->duration_error[j][0][i] += error;
2362 38952248 info->duration_error[j][1][i] += error*error;
2363 }
2364 }
2365 }
2366
1/2
✓ Branch 0 taken 126017 times.
✗ Branch 1 not taken.
 126017 if (info->rfps_duration_sum <= INT64_MAX - duration) {
2367 126017 info->duration_count++;
2368 126017 info->rfps_duration_sum += duration;
2369 }
2370
2371
2/2
✓ Branch 0 taken 11433 times.
✓ Branch 1 taken 114584 times.
 126017 if (info->duration_count % 10 == 0) {
2372 11433 int n = info->duration_count;
2373
2/2
✓ Branch 0 taken 4561767 times.
✓ Branch 1 taken 11433 times.
 4573200 for (int i = 0; i < MAX_STD_TIMEBASES; i++) {
2374
2/2
✓ Branch 0 taken 1856790 times.
✓ Branch 1 taken 2704977 times.
 4561767 if (info->duration_error[0][1][i] < 1e10) {
2375 1856790 double a0 = info->duration_error[0][0][i] / n;
2376 1856790 double error0 = info->duration_error[0][1][i] / n - a0*a0;
2377 1856790 double a1 = info->duration_error[1][0][i] / n;
2378 1856790 double error1 = info->duration_error[1][1][i] / n - a1*a1;
2379
4/4
✓ Branch 0 taken 1521194 times.
✓ Branch 1 taken 335596 times.
✓ Branch 2 taken 1419980 times.
✓ Branch 3 taken 101214 times.
 1856790 if (error0 > 0.04 && error1 > 0.04) {
2380 1419980 info->duration_error[0][1][i] = 2e10;
2381 1419980 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 113678 times.
✓ Branch 1 taken 12339 times.
✓ Branch 4 taken 113678 times.
✗ Branch 5 not taken.
 126017 if (info->duration_count > 3 && is_relative(ts) == is_relative(last))
2389 113678 info->duration_gcd = av_gcd(info->duration_gcd, duration);
2390 }
2391
2/2
✓ Branch 0 taken 132484 times.
✓ Branch 1 taken 16906 times.
 149390 if (ts != AV_NOPTS_VALUE)
2392 132484 info->last_dts = ts;
2393
2394 149390 return 0;
2395 }
2396
2397 8871 void ff_rfps_calculate(AVFormatContext *ic)
2398 {
2399
2/2
✓ Branch 0 taken 10103 times.
✓ Branch 1 taken 8871 times.
 18974 for (unsigned i = 0; i < ic->nb_streams; i++) {
2400 10103 AVStream *const st = ic->streams[i];
2401 10103 FFStream *const sti = ffstream(st);
2402
2403
2/2
✓ Branch 0 taken 3018 times.
✓ Branch 1 taken 7085 times.
 10103 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2404 3018 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 5642 times.
✓ Branch 2 taken 1443 times.
✓ Branch 3 taken 3565 times.
✓ Branch 4 taken 2077 times.
✓ Branch 5 taken 357 times.
✓ Branch 6 taken 3208 times.
✓ Branch 7 taken 175 times.
✓ Branch 8 taken 182 times.
 7085 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 175 times.
✗ Branch 1 not taken.
 175 sti->info->duration_gcd < INT64_MAX / st->time_base.num)
2410 175 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 4104 times.
✓ Branch 1 taken 2981 times.
✓ Branch 2 taken 426 times.
✓ Branch 3 taken 3678 times.
 7085 if (sti->info->duration_count > 1 && !st->r_frame_rate.num
2412
2/2
✓ Branch 1 taken 317 times.
✓ Branch 2 taken 109 times.
 426 && tb_unreliable(ic, st)) {
2413 317 int num = 0;
2414 317 double best_error = 0.01;
2415
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 317 times.
 317 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 126483 times.
✓ Branch 1 taken 317 times.
 126800 for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
2418
2/2
✓ Branch 0 taken 93366 times.
✓ Branch 1 taken 33117 times.
 126483 if (sti->info->codec_info_duration &&
2419
2/2
✓ Branch 2 taken 10066 times.
✓ Branch 3 taken 83300 times.
 93366 sti->info->codec_info_duration*av_q2d(st->time_base) < (1001*11.5)/get_std_framerate(j))
2420 10066 continue;
2421
4/4
✓ Branch 0 taken 33117 times.
✓ Branch 1 taken 83300 times.
✓ Branch 3 taken 913 times.
✓ Branch 4 taken 32204 times.
 116417 if (!sti->info->codec_info_duration && get_std_framerate(j) < 1001*12)
2422 913 continue;
2423
2424
2/2
✓ Branch 2 taken 54413 times.
✓ Branch 3 taken 61091 times.
 115504 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 54413 continue;
2426
2427
2/2
✓ Branch 0 taken 122182 times.
✓ Branch 1 taken 61091 times.
 183273 for (int k = 0; k < 2; k++) {
2428 122182 int n = sti->info->duration_count;
2429 122182 double a = sti->info->duration_error[k][0][j] / n;
2430 122182 double error = sti->info->duration_error[k][1][j]/n - a*a;
2431
2432
4/4
✓ Branch 0 taken 4608 times.
✓ Branch 1 taken 117574 times.
✓ Branch 2 taken 4537 times.
✓ Branch 3 taken 71 times.
 122182 if (error < best_error && best_error> 0.000000001) {
2433 4537 best_error= error;
2434 4537 num = get_std_framerate(j);
2435 }
2436
2/2
✓ Branch 0 taken 25147 times.
✓ Branch 1 taken 97035 times.
 122182 if (error < 0.02)
2437 25147 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 311 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 311 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 309 times.
✓ Branch 6 taken 2 times.
 317 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2442 309 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2443 }
2444
2/2
✓ Branch 0 taken 1175 times.
✓ Branch 1 taken 5910 times.
 7085 if ( !st->avg_frame_rate.num
2445
4/4
✓ Branch 0 taken 336 times.
✓ Branch 1 taken 839 times.
✓ Branch 2 taken 331 times.
✓ Branch 3 taken 5 times.
 1175 && st->r_frame_rate.num && sti->info->rfps_duration_sum
2446
2/2
✓ Branch 0 taken 79 times.
✓ Branch 1 taken 252 times.
 331 && 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 7085 av_freep(&sti->info->duration_error);
2455 7085 sti->info->last_dts = AV_NOPTS_VALUE;
2456 7085 sti->info->duration_count = 0;
2457 7085 sti->info->rfps_duration_sum = 0;
2458 }
2459 8871 }
2460
2461 9684 static int extract_extradata_check(AVStream *st)
2462 {
2463 9684 const AVBitStreamFilter *const f = av_bsf_get_by_name("extract_extradata");
2464
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9684 times.
 9684 if (!f)
2465 ✗ return 0;
2466
2467
1/2
✓ Branch 0 taken 9684 times.
✗ Branch 1 not taken.
 9684 if (f->codec_ids) {
2468 const enum AVCodecID *ids;
2469
2/2
✓ Branch 0 taken 111748 times.
✓ Branch 1 taken 8710 times.
 120458 for (ids = f->codec_ids; *ids != AV_CODEC_ID_NONE; ids++)
2470
2/2
✓ Branch 0 taken 974 times.
✓ Branch 1 taken 110774 times.
 111748 if (*ids == st->codecpar->codec_id)
2471 974 return 1;
2472 }
2473
2474 8710 return 0;
2475 }
2476
2477 7552 static int extract_extradata_init(AVStream *st)
2478 {
2479 7552 FFStream *const sti = ffstream(st);
2480 const AVBitStreamFilter *f;
2481 int ret;
2482
2483 7552 f = av_bsf_get_by_name("extract_extradata");
2484
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7552 times.
 7552 if (!f)
2485 ✗ goto finish;
2486
2487 /* check that the codec id is supported */
2488 7552 ret = extract_extradata_check(st);
2489
2/2
✓ Branch 0 taken 6688 times.
✓ Branch 1 taken 864 times.
 7552 if (!ret)
2490 6688 goto finish;
2491
2492 864 av_bsf_free(&sti->extract_extradata.bsf);
2493 864 ret = av_bsf_alloc(f, &sti->extract_extradata.bsf);
2494
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 864 times.
 864 if (ret < 0)
2495 ✗ return ret;
2496
2497 864 ret = avcodec_parameters_copy(sti->extract_extradata.bsf->par_in,
2498 864 st->codecpar);
2499
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 864 times.
 864 if (ret < 0)
2500 ✗ goto fail;
2501
2502 864 sti->extract_extradata.bsf->time_base_in = st->time_base;
2503
2504 864 ret = av_bsf_init(sti->extract_extradata.bsf);
2505
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 864 times.
 864 if (ret < 0)
2506 ✗ goto fail;
2507
2508 864 finish:
2509 7552 sti->extract_extradata.inited = 1;
2510
2511 7552 return 0;
2512 ✗ fail:
2513 ✗ av_bsf_free(&sti->extract_extradata.bsf);
2514 ✗ return ret;
2515 }
2516
2517 169172 static int extract_extradata(FFFormatContext *si, AVStream *st, const AVPacket *pkt)
2518 {
2519 169172 FFStream *const sti = ffstream(st);
2520 169172 AVPacket *const pkt_ref = si->parse_pkt;
2521 int ret;
2522
2523
2/2
✓ Branch 0 taken 7552 times.
✓ Branch 1 taken 161620 times.
 169172 if (!sti->extract_extradata.inited) {
2524 7552 ret = extract_extradata_init(st);
2525
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7552 times.
 7552 if (ret < 0)
2526 ✗ return ret;
2527 }
2528
2529
3/4
✓ Branch 0 taken 169172 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 167889 times.
✓ Branch 3 taken 1283 times.
 169172 if (sti->extract_extradata.inited && !sti->extract_extradata.bsf)
2530 167889 return 0;
2531
2532 1283 ret = av_packet_ref(pkt_ref, pkt);
2533
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1283 times.
 1283 if (ret < 0)
2534 ✗ return ret;
2535
2536 1283 ret = av_bsf_send_packet(sti->extract_extradata.bsf, pkt_ref);
2537
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1283 times.
 1283 if (ret < 0) {
2538 ✗ av_packet_unref(pkt_ref);
2539 ✗ return ret;
2540 }
2541
2542
4/4
✓ Branch 0 taken 2566 times.
✓ Branch 1 taken 416 times.
✓ Branch 2 taken 1699 times.
✓ Branch 3 taken 867 times.
 2982 while (ret >= 0 && !sti->avctx->extradata) {
2543 1699 ret = av_bsf_receive_packet(sti->extract_extradata.bsf, pkt_ref);
2544
2/2
✓ Branch 0 taken 416 times.
✓ Branch 1 taken 1283 times.
 1699 if (ret < 0) {
2545
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 416 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 416 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
2546 ✗ return ret;
2547 416 continue;
2548 }
2549
2550
2/2
✓ Branch 0 taken 1176 times.
✓ Branch 1 taken 416 times.
 1592 for (int i = 0; i < pkt_ref->side_data_elems; i++) {
2551 1176 AVPacketSideData *const side_data = &pkt_ref->side_data[i];
2552
2/2
✓ Branch 0 taken 867 times.
✓ Branch 1 taken 309 times.
 1176 if (side_data->type == AV_PKT_DATA_NEW_EXTRADATA) {
2553 867 sti->avctx->extradata = side_data->data;
2554 867 sti->avctx->extradata_size = side_data->size;
2555 867 side_data->data = NULL;
2556 867 side_data->size = 0;
2557 867 break;
2558 }
2559 }
2560 1283 av_packet_unref(pkt_ref);
2561 }
2562
2563 1283 return 0;
2564 }
2565
2566 9248 static int parameters_from_context(AVFormatContext *ic, AVCodecParameters *par,
2567 const AVCodecContext *avctx)
2568 {
2569 AVCodecParameters *par_tmp;
2570 int ret;
2571
2572 9248 par_tmp = avcodec_parameters_alloc();
2573
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9248 times.
 9248 if (!par_tmp)
2574 ✗ return AVERROR(ENOMEM);
2575
2576 9248 ret = avcodec_parameters_copy(par_tmp, par);
2577
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9248 times.
 9248 if (ret < 0)
2578 ✗ goto fail;
2579
2580 9248 ret = avcodec_parameters_from_context(par, avctx);
2581
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9248 times.
 9248 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 235 times.
✓ Branch 1 taken 9013 times.
 9248 if (par_tmp->color_range != AVCOL_RANGE_UNSPECIFIED)
2589 235 par->color_range = par_tmp->color_range;
2590
2/2
✓ Branch 0 taken 104 times.
✓ Branch 1 taken 9144 times.
 9248 if (par_tmp->color_primaries != AVCOL_PRI_UNSPECIFIED)
2591 104 par->color_primaries = par_tmp->color_primaries;
2592
2/2
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 9128 times.
 9248 if (par_tmp->color_trc != AVCOL_TRC_UNSPECIFIED)
2593 120 par->color_trc = par_tmp->color_trc;
2594
2/2
✓ Branch 0 taken 120 times.
✓ Branch 1 taken 9128 times.
 9248 if (par_tmp->color_space != AVCOL_SPC_UNSPECIFIED)
2595 120 par->color_space = par_tmp->color_space;
2596
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 9190 times.
 9248 if (par_tmp->chroma_location != AVCHROMA_LOC_UNSPECIFIED)
2597 58 par->chroma_location = par_tmp->chroma_location;
2598
2599 /* A failed avcodec_open2() zeroes ch_layout through
2600 * ff_codec_close() -> av_opt_free(); do not copy that empty layout
2601 * over a container-signaled one. Other AVOption types used here are
2602 * integers and are not cleared. */
2603
4/4
✓ Branch 0 taken 2343 times.
✓ Branch 1 taken 6905 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 2342 times.
 9248 if (par_tmp->ch_layout.nb_channels > 0 && !par->ch_layout.nb_channels) {
2604 1 ret = av_channel_layout_copy(&par->ch_layout, &par_tmp->ch_layout);
2605
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
2606 ✗ goto fail;
2607 }
2608
2609 9248 ret = 0;
2610 9248 fail:
2611 9248 avcodec_parameters_free(&par_tmp);
2612
2613 9248 return ret;
2614 }
2615
2616 8258 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2617 {
2618 8258 FFFormatContext *const si = ffformatcontext(ic);
2619 8258 int count = 0, ret = 0, err;
2620 int64_t read_size;
2621 8258 AVPacket *pkt1 = si->pkt;
2622 8258 int64_t old_offset = avio_tell(ic->pb);
2623 // new streams might appear, no options for those
2624 8258 int orig_nb_streams = ic->nb_streams;
2625 int flush_codecs;
2626 8258 int64_t max_analyze_duration = ic->max_analyze_duration;
2627 int64_t max_stream_analyze_duration;
2628 int64_t max_subtitle_analyze_duration;
2629 8258 int64_t probesize = ic->probesize;
2630 8258 int eof_reached = 0;
2631
2632 8258 flush_codecs = probesize > 0;
2633
2634 8258 av_opt_set_int(ic, "skip_clear", 1, AV_OPT_SEARCH_CHILDREN);
2635
2636 8258 max_stream_analyze_duration = max_analyze_duration;
2637 8258 max_subtitle_analyze_duration = max_analyze_duration;
2638
2/2
✓ Branch 0 taken 8256 times.
✓ Branch 1 taken 2 times.
 8258 if (!max_analyze_duration) {
2639 8256 max_stream_analyze_duration =
2640 8256 max_analyze_duration = 5*AV_TIME_BASE;
2641 8256 max_subtitle_analyze_duration = 30*AV_TIME_BASE;
2642
2/2
✓ Branch 0 taken 39 times.
✓ Branch 1 taken 8217 times.
 8256 if (!strcmp(ic->iformat->name, "flv"))
2643 39 max_stream_analyze_duration = 90*AV_TIME_BASE;
2644
4/4
✓ Branch 0 taken 8228 times.
✓ Branch 1 taken 28 times.
✓ Branch 2 taken 67 times.
✓ Branch 3 taken 8161 times.
 8256 if (!strcmp(ic->iformat->name, "mpeg") || !strcmp(ic->iformat->name, "mpegts"))
2645 95 max_stream_analyze_duration = 7*AV_TIME_BASE;
2646 }
2647
2648
2/2
✓ Branch 0 taken 5060 times.
✓ Branch 1 taken 3198 times.
 8258 if (ic->pb) {
2649 5060 FFIOContext *const ctx = ffiocontext(ic->pb);
2650 5060 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d nb_streams:%d\n",
2651 avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, ic->nb_streams);
2652 }
2653
2654
2/2
✓ Branch 0 taken 9072 times.
✓ Branch 1 taken 8258 times.
 17330 for (unsigned i = 0; i < ic->nb_streams; i++) {
2655 const AVCodec *codec;
2656 9072 AVDictionary *thread_opt = NULL;
2657 9072 AVStream *const st = ic->streams[i];
2658 9072 FFStream *const sti = ffstream(st);
2659 9072 AVCodecContext *const avctx = sti->avctx;
2660
2661 /* check if the caller has overridden the codec id */
2662 // only for the split stuff
2663
4/6
✓ Branch 0 taken 9072 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9072 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 8506 times.
✓ Branch 5 taken 566 times.
 9072 if (!sti->parser && !(ic->flags & AVFMT_FLAG_NOPARSE) && sti->request_probe <= 0) {
2664 8506 sti->parser = av_parser_init(st->codecpar->codec_id);
2665
2/2
✓ Branch 0 taken 5956 times.
✓ Branch 1 taken 2550 times.
 8506 if (sti->parser) {
2666
2/2
✓ Branch 0 taken 845 times.
✓ Branch 1 taken 5111 times.
 5956 if (sti->need_parsing == AVSTREAM_PARSE_HEADERS) {
2667 845 sti->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2668
2/2
✓ Branch 0 taken 958 times.
✓ Branch 1 taken 4153 times.
 5111 } else if (sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2669 958 sti->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2670 }
2671
2/2
✓ Branch 0 taken 682 times.
✓ Branch 1 taken 1868 times.
 2550 } else if (sti->need_parsing) {
2672 682 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2673 "%s, packets or times may be invalid.\n",
2674 682 avcodec_get_name(st->codecpar->codec_id));
2675 }
2676 }
2677
2678 9072 ret = avcodec_parameters_to_context(avctx, st->codecpar);
2679
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9072 times.
 9072 if (ret < 0)
2680 ✗ goto find_stream_info_err;
2681
2/2
✓ Branch 0 taken 8506 times.
✓ Branch 1 taken 566 times.
 9072 if (sti->request_probe <= 0)
2682 8506 sti->avctx_inited = 1;
2683
2684 9072 codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2685
2686 /* Force thread count to 1 since the H.264 decoder will not extract
2687 * SPS and PPS to extradata during multi-threaded decoding. */
2688
2/2
✓ Branch 0 taken 8768 times.
✓ Branch 1 taken 304 times.
 9072 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2689 /* Force lowres to 0. The decoder might reduce the video size by the
2690 * lowres factor, and we don't want that propagated to the stream's
2691 * codecpar */
2692
2/2
✓ Branch 0 taken 8768 times.
✓ Branch 1 taken 304 times.
 9072 av_dict_set(options ? &options[i] : &thread_opt, "lowres", "0", 0);
2693
2694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9072 times.
 9072 if (ic->codec_whitelist)
2695 ✗ av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
2696
2697 // Try to just open decoders, in case this is enough to get parameters.
2698 // Also ensure that subtitle_header is properly set.
2699
4/4
✓ Branch 1 taken 8171 times.
✓ Branch 2 taken 901 times.
✓ Branch 3 taken 565 times.
✓ Branch 4 taken 7606 times.
 9072 if (!has_codec_parameters(st, NULL) && sti->request_probe <= 0 ||
2700
2/2
✓ Branch 0 taken 90 times.
✓ Branch 1 taken 1376 times.
 1466 st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2701
3/4
✓ Branch 0 taken 7654 times.
✓ Branch 1 taken 42 times.
✓ Branch 2 taken 7654 times.
✗ Branch 3 not taken.
 7696 if (codec && !avctx->codec)
2702
4/4
✓ Branch 0 taken 7356 times.
✓ Branch 1 taken 298 times.
✓ Branch 3 taken 7 times.
✓ Branch 4 taken 7647 times.
 7654 if (avcodec_open2(avctx, codec, options ? &options[i] : &thread_opt) < 0)
2703 7 av_log(ic, AV_LOG_WARNING,
2704 "Failed to open codec in %s\n", __func__);
2705 }
2706
2/2
✓ Branch 0 taken 304 times.
✓ Branch 1 taken 8768 times.
 9072 if (!options)
2707 304 av_dict_free(&thread_opt);
2708 }
2709
2710 8258 read_size = 0;
2711 202317 for (;;) {
2712 const AVPacket *pkt;
2713 AVStream *st;
2714 FFStream *sti;
2715 AVCodecContext *avctx;
2716 int analyzed_all_streams;
2717 unsigned i;
2718
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 210575 times.
 210575 if (ff_check_interrupt(&ic->interrupt_callback)) {
2719 ✗ ret = AVERROR_EXIT;
2720 ✗ av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2721 ✗ break;
2722 }
2723
2724 /* read_frame_internal() in a previous iteration of this loop may
2725 * have made changes to streams without returning a packet for them.
2726 * Handle that here. */
2727 210575 ret = update_stream_avctx(ic);
2728
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 210575 times.
 210575 if (ret < 0)
2729 ✗ goto unref_then_goto_end;
2730
2731 /* check if one codec still needs to be handled */
2732
2/2
✓ Branch 0 taken 219851 times.
✓ Branch 1 taken 115250 times.
 335101 for (i = 0; i < ic->nb_streams; i++) {
2733 219851 AVStream *const st = ic->streams[i];
2734 219851 FFStream *const sti = ffstream(st);
2735 219851 int fps_analyze_framecount = 20;
2736 int count;
2737
2738
2/2
✓ Branch 1 taken 8026 times.
✓ Branch 2 taken 211825 times.
 219851 if (!has_codec_parameters(st, NULL))
2739 8026 break;
2740 /* If the timebase is coarse (like the usual millisecond precision
2741 * of mkv), we need to analyze more frames to reliably arrive at
2742 * the correct fps. */
2743
2/2
✓ Branch 1 taken 125612 times.
✓ Branch 2 taken 86213 times.
 211825 if (av_q2d(st->time_base) > 0.0005)
2744 125612 fps_analyze_framecount *= 2;
2745
2/2
✓ Branch 1 taken 8724 times.
✓ Branch 2 taken 203101 times.
 211825 if (!tb_unreliable(ic, st))
2746 8724 fps_analyze_framecount = 0;
2747
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 211825 times.
 211825 if (ic->fps_probe_size >= 0)
2748 ✗ fps_analyze_framecount = ic->fps_probe_size;
2749
2/2
✓ Branch 0 taken 52 times.
✓ Branch 1 taken 211773 times.
 211825 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2750 52 fps_analyze_framecount = 0;
2751 /* variable fps and no guess at the real fps */
2752
2/2
✓ Branch 0 taken 20203 times.
✓ Branch 1 taken 191622 times.
 211825 count = (ic->iformat->flags & AVFMT_NOTIMESTAMPS) ?
2753 20203 sti->info->codec_info_duration_fields/2 :
2754 191622 sti->info->duration_count;
2755
4/4
✓ Branch 0 taken 106011 times.
✓ Branch 1 taken 105814 times.
✓ Branch 2 taken 423 times.
✓ Branch 3 taken 105588 times.
 211825 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
2756
2/2
✓ Branch 0 taken 45681 times.
✓ Branch 1 taken 60556 times.
 106237 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2757
2/2
✓ Branch 0 taken 26859 times.
✓ Branch 1 taken 18822 times.
 45681 if (count < fps_analyze_framecount)
2758 26859 break;
2759 }
2760 // Look at the first 3 frames if there is evidence of frame delay
2761 // but the decoder delay is not set.
2762
6/6
✓ Branch 0 taken 3438 times.
✓ Branch 1 taken 181528 times.
✓ Branch 2 taken 178 times.
✓ Branch 3 taken 3260 times.
✓ Branch 4 taken 8 times.
✓ Branch 5 taken 170 times.
 184966 if (sti->info->frame_delay_evidence && count < 2 && sti->avctx->has_b_frames == 0)
2763 8 break;
2764
2/2
✓ Branch 0 taken 163236 times.
✓ Branch 1 taken 21722 times.
 184958 if (!sti->avctx->extradata &&
2765
6/6
✓ Branch 0 taken 161214 times.
✓ Branch 1 taken 2022 times.
✓ Branch 2 taken 110 times.
✓ Branch 3 taken 161104 times.
✓ Branch 4 taken 110 times.
✓ Branch 5 taken 2022 times.
 165368 (!sti->extract_extradata.inited || sti->extract_extradata.bsf) &&
2766 2132 extract_extradata_check(st))
2767 110 break;
2768
2/2
✓ Branch 0 taken 63793 times.
✓ Branch 1 taken 121055 times.
 184848 if (sti->first_dts == AV_NOPTS_VALUE &&
2769
6/6
✓ Branch 0 taken 9877 times.
✓ Branch 1 taken 53916 times.
✓ Branch 2 taken 9612 times.
✓ Branch 3 taken 265 times.
✓ Branch 4 taken 61189 times.
✓ Branch 5 taken 2339 times.
 127321 (!(ic->iformat->flags & AVFMT_NOTIMESTAMPS) || sti->need_parsing == AVSTREAM_PARSE_FULL_RAW) &&
2770
2/2
✓ Branch 0 taken 63476 times.
✓ Branch 1 taken 52 times.
 63528 sti->codec_info_nb_frames < ((st->disposition & AV_DISPOSITION_ATTACHED_PIC) ? 1 : ic->max_ts_probe) &&
2771
2/2
✓ Branch 0 taken 44876 times.
✓ Branch 1 taken 16313 times.
 61189 (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2772
2/2
✓ Branch 0 taken 867 times.
✓ Branch 1 taken 44009 times.
 44876 st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO))
2773 break;
2774 }
2775 210575 analyzed_all_streams = 0;
2776
4/4
✓ Branch 0 taken 115250 times.
✓ Branch 1 taken 95325 times.
✓ Branch 2 taken 115210 times.
✓ Branch 3 taken 40 times.
 210575 if (i == ic->nb_streams && !si->missing_streams) {
2777 115210 analyzed_all_streams = 1;
2778 /* NOTE: If the format has no header, then we need to read some
2779 * packets to get most of the streams, so we cannot stop here. */
2780
2/2
✓ Branch 0 taken 3662 times.
✓ Branch 1 taken 111548 times.
 115210 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2781 /* If we found the info for all the codecs, we can stop. */
2782 3662 ret = count;
2783 3662 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2784 3662 flush_codecs = 0;
2785 3662 break;
2786 }
2787 }
2788 /* We did not get all the codec info, but we read too much data. */
2789
2/2
✓ Branch 0 taken 3093 times.
✓ Branch 1 taken 203820 times.
 206913 if (read_size >= probesize) {
2790 3093 ret = count;
2791 3093 av_log(ic, AV_LOG_DEBUG,
2792 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
2793
2/2
✓ Branch 0 taken 3107 times.
✓ Branch 1 taken 3093 times.
 6200 for (unsigned i = 0; i < ic->nb_streams; i++) {
2794 3107 AVStream *const st = ic->streams[i];
2795 3107 FFStream *const sti = ffstream(st);
2796
2/2
✓ Branch 0 taken 57 times.
✓ Branch 1 taken 3050 times.
 3107 if (!st->r_frame_rate.num &&
2797
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 40 times.
 57 sti->info->duration_count <= 1 &&
2798
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16 times.
 17 st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2799
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 strcmp(ic->iformat->name, "image2"))
2800 1 av_log(ic, AV_LOG_WARNING,
2801 "Stream #%d: not enough frames to estimate rate; "
2802 "consider increasing probesize\n", i);
2803 }
2804 3093 break;
2805 }
2806
2807 /* NOTE: A new stream can be added there if no header in file
2808 * (AVFMTCTX_NOHEADER). */
2809 203820 ret = read_frame_internal(ic, pkt1);
2810
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 203820 times.
 203820 if (ret == AVERROR(EAGAIN))
2811 ✗ continue;
2812
2813
2/2
✓ Branch 0 taken 1407 times.
✓ Branch 1 taken 202413 times.
 203820 if (ret < 0) {
2814 /* EOF or error*/
2815 1407 eof_reached = 1;
2816 1407 break;
2817 }
2818
2819
1/2
✓ Branch 0 taken 202413 times.
✗ Branch 1 not taken.
 202413 if (!(ic->flags & AVFMT_FLAG_NOBUFFER)) {
2820 202413 ret = ff_packet_list_put(&si->packet_buffer,
2821 pkt1, NULL, 0);
2822
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 202413 times.
 202413 if (ret < 0)
2823 ✗ goto unref_then_goto_end;
2824
2825 202413 pkt = &si->packet_buffer.tail->pkt;
2826 } else {
2827 ✗ pkt = pkt1;
2828 }
2829
2830 202413 st = ic->streams[pkt->stream_index];
2831 202413 sti = ffstream(st);
2832
2/2
✓ Branch 0 taken 202347 times.
✓ Branch 1 taken 66 times.
 202413 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2833 202347 read_size += pkt->size;
2834
2835 202413 avctx = sti->avctx;
2836
2/2
✓ Branch 0 taken 742 times.
✓ Branch 1 taken 201671 times.
 202413 if (!sti->avctx_inited) {
2837 742 ret = avcodec_parameters_to_context(avctx, st->codecpar);
2838
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 742 times.
 742 if (ret < 0)
2839 ✗ goto unref_then_goto_end;
2840 742 sti->avctx_inited = 1;
2841 }
2842
2843
4/4
✓ Branch 0 taken 185116 times.
✓ Branch 1 taken 17297 times.
✓ Branch 2 taken 171860 times.
✓ Branch 3 taken 13256 times.
 202413 if (pkt->dts != AV_NOPTS_VALUE && sti->codec_info_nb_frames > 1) {
2844 /* check for non-increasing dts */
2845
2/2
✓ Branch 0 taken 166661 times.
✓ Branch 1 taken 5199 times.
 171860 if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2846
2/2
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 166636 times.
 166661 sti->info->fps_last_dts >= pkt->dts) {
2847 25 av_log(ic, AV_LOG_DEBUG,
2848 "Non-increasing DTS in stream %d: packet %d with DTS "
2849 "%"PRId64", packet %d with DTS %"PRId64"\n",
2850 25 st->index, sti->info->fps_last_dts_idx,
2851 25 sti->info->fps_last_dts, sti->codec_info_nb_frames,
2852 25 pkt->dts);
2853 25 sti->info->fps_first_dts =
2854 25 sti->info->fps_last_dts = AV_NOPTS_VALUE;
2855 }
2856 /* Check for a discontinuity in dts. If the difference in dts
2857 * is more than 1000 times the average packet duration in the
2858 * sequence, we treat it as a discontinuity. */
2859
2/2
✓ Branch 0 taken 166636 times.
✓ Branch 1 taken 5224 times.
 171860 if (sti->info->fps_last_dts != AV_NOPTS_VALUE &&
2860
2/2
✓ Branch 0 taken 161470 times.
✓ Branch 1 taken 5166 times.
 166636 sti->info->fps_last_dts_idx > sti->info->fps_first_dts_idx &&
2861 161470 (pkt->dts - (uint64_t)sti->info->fps_last_dts) / 1000 >
2862 161470 (sti->info->fps_last_dts - (uint64_t)sti->info->fps_first_dts) /
2863
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 161470 times.
 161470 (sti->info->fps_last_dts_idx - sti->info->fps_first_dts_idx)) {
2864 ✗ av_log(ic, AV_LOG_WARNING,
2865 "DTS discontinuity in stream %d: packet %d with DTS "
2866 "%"PRId64", packet %d with DTS %"PRId64"\n",
2867 ✗ st->index, sti->info->fps_last_dts_idx,
2868 ✗ sti->info->fps_last_dts, sti->codec_info_nb_frames,
2869 ✗ pkt->dts);
2870 ✗ sti->info->fps_first_dts =
2871 ✗ sti->info->fps_last_dts = AV_NOPTS_VALUE;
2872 }
2873
2874 /* update stored dts values */
2875
2/2
✓ Branch 0 taken 5224 times.
✓ Branch 1 taken 166636 times.
 171860 if (sti->info->fps_first_dts == AV_NOPTS_VALUE) {
2876 5224 sti->info->fps_first_dts = pkt->dts;
2877 5224 sti->info->fps_first_dts_idx = sti->codec_info_nb_frames;
2878 }
2879 171860 sti->info->fps_last_dts = pkt->dts;
2880 171860 sti->info->fps_last_dts_idx = sti->codec_info_nb_frames;
2881 }
2882
2/2
✓ Branch 0 taken 187840 times.
✓ Branch 1 taken 14573 times.
 202413 if (sti->codec_info_nb_frames > 1) {
2883 187840 int64_t t = 0;
2884 int64_t limit;
2885
2886
1/2
✓ Branch 0 taken 187840 times.
✗ Branch 1 not taken.
 187840 if (st->time_base.den > 0)
2887 187840 t = av_rescale_q(sti->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2888
2/2
✓ Branch 0 taken 117405 times.
✓ Branch 1 taken 70435 times.
 187840 if (st->avg_frame_rate.num > 0)
2889
2/2
✓ Branch 1 taken 116878 times.
✓ Branch 2 taken 527 times.
 117405 t = FFMAX(t, av_rescale_q(sti->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2890
2891
2/2
✓ Branch 0 taken 4690 times.
✓ Branch 1 taken 183150 times.
 187840 if ( t == 0
2892
2/2
✓ Branch 0 taken 564 times.
✓ Branch 1 taken 4126 times.
 4690 && sti->codec_info_nb_frames > 30
2893
2/2
✓ Branch 0 taken 497 times.
✓ Branch 1 taken 67 times.
 564 && sti->info->fps_first_dts != AV_NOPTS_VALUE
2894
1/2
✓ Branch 0 taken 497 times.
✗ Branch 1 not taken.
 497 && sti->info->fps_last_dts != AV_NOPTS_VALUE) {
2895 497 int64_t dur = av_sat_sub64(sti->info->fps_last_dts, sti->info->fps_first_dts);
2896
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));
2897 }
2898
2899
2/2
✓ Branch 0 taken 105060 times.
✓ Branch 1 taken 82780 times.
 187840 if (analyzed_all_streams) limit = max_analyze_duration;
2900
2/2
✓ Branch 0 taken 91 times.
✓ Branch 1 taken 82689 times.
 82780 else if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) limit = max_subtitle_analyze_duration;
2901 82689 else limit = max_stream_analyze_duration;
2902
2903
2/2
✓ Branch 0 taken 96 times.
✓ Branch 1 taken 187744 times.
 187840 if (t >= limit) {
2904 96 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds st:%d\n",
2905 limit,
2906 96 t, pkt->stream_index);
2907
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 96 times.
 96 if (ic->flags & AVFMT_FLAG_NOBUFFER)
2908 ✗ av_packet_unref(pkt1);
2909 96 break;
2910 }
2911
3/4
✓ Branch 0 taken 183691 times.
✓ Branch 1 taken 4053 times.
✓ Branch 2 taken 183691 times.
✗ Branch 3 not taken.
 187744 if (pkt->duration > 0 && pkt->duration < INT64_MAX - sti->info->codec_info_duration) {
2912
4/4
✓ Branch 0 taken 183651 times.
✓ Branch 1 taken 40 times.
✓ Branch 2 taken 15057 times.
✓ Branch 3 taken 168594 times.
 183691 const int fields = sti->codec_desc && (sti->codec_desc->props & AV_CODEC_PROP_FIELDS);
2913
1/8
✗ Branch 0 not taken.
✓ Branch 1 taken 183691 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.
 183691 if (avctx->codec_type == AVMEDIA_TYPE_SUBTITLE && pkt->pts != AV_NOPTS_VALUE && st->start_time != AV_NOPTS_VALUE && pkt->pts >= st->start_time
2914 ✗ && (uint64_t)pkt->pts - st->start_time < INT64_MAX
2915 ) {
2916 ✗ sti->info->codec_info_duration = FFMIN(pkt->pts - st->start_time, sti->info->codec_info_duration + pkt->duration);
2917 } else
2918 183691 sti->info->codec_info_duration += pkt->duration;
2919
4/4
✓ Branch 0 taken 40028 times.
✓ Branch 1 taken 96161 times.
✓ Branch 2 taken 14381 times.
✓ Branch 3 taken 25647 times.
 319880 sti->info->codec_info_duration_fields += sti->parser && sti->need_parsing && fields
2920
2/2
✓ Branch 0 taken 136189 times.
✓ Branch 1 taken 47502 times.
 319880 ? sti->parser->repeat_pict + 1 : 2;
2921 }
2922 }
2923
2/2
✓ Branch 0 taken 137703 times.
✓ Branch 1 taken 64614 times.
 202317 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2924 #if FF_API_R_FRAME_RATE
2925 137703 ff_rfps_add_frame(ic, st, pkt->dts);
2926 #endif
2927
6/6
✓ Branch 0 taken 5149 times.
✓ Branch 1 taken 132554 times.
✓ Branch 2 taken 4847 times.
✓ Branch 3 taken 302 times.
✓ Branch 4 taken 2820 times.
✓ Branch 5 taken 2027 times.
 137703 if (pkt->dts != pkt->pts && pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
2928 2820 sti->info->frame_delay_evidence = 1;
2929 }
2930
2/2
✓ Branch 0 taken 169025 times.
✓ Branch 1 taken 33292 times.
 202317 if (!sti->avctx->extradata) {
2931 169025 ret = extract_extradata(si, st, pkt);
2932
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 169025 times.
 169025 if (ret < 0)
2933 ✗ goto unref_then_goto_end;
2934 }
2935
2936 /* If still no information, we try to open the codec and to
2937 * decompress the frame. We try to avoid that in most cases as
2938 * it takes longer and uses more memory. For MPEG-4, we need to
2939 * decompress for QuickTime.
2940 *
2941 * If AV_CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2942 * least one frame of codec data, this makes sure the codec initializes
2943 * the channel configuration and does not only trust the values from
2944 * the container. */
2945
2/2
✓ Branch 0 taken 184371 times.
✓ Branch 1 taken 17946 times.
 386688 try_decode_frame(ic, st, pkt,
2946
2/2
✓ Branch 0 taken 83462 times.
✓ Branch 1 taken 100909 times.
 184371 (options && i < orig_nb_streams) ? &options[i] : NULL);
2947
2948
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 202317 times.
 202317 if (ic->flags & AVFMT_FLAG_NOBUFFER)
2949 ✗ av_packet_unref(pkt1);
2950
2951 202317 sti->codec_info_nb_frames++;
2952 202317 count++;
2953 }
2954
2955
2/2
✓ Branch 0 taken 1407 times.
✓ Branch 1 taken 6851 times.
 8258 if (eof_reached) {
2956
2/2
✓ Branch 0 taken 1754 times.
✓ Branch 1 taken 1407 times.
 3161 for (unsigned stream_index = 0; stream_index < ic->nb_streams; stream_index++) {
2957 1754 AVStream *const st = ic->streams[stream_index];
2958 1754 AVCodecContext *const avctx = ffstream(st)->avctx;
2959
2/2
✓ Branch 1 taken 40 times.
✓ Branch 2 taken 1714 times.
 1754 if (!has_codec_parameters(st, NULL)) {
2960 40 const AVCodec *codec = find_probe_decoder(ic, st, st->codecpar->codec_id);
2961
4/4
✓ Branch 0 taken 25 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 14 times.
 40 if (codec && !avctx->codec) {
2962 11 AVDictionary *opts = NULL;
2963
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (ic->codec_whitelist)
2964 ✗ av_dict_set(&opts, "codec_whitelist", ic->codec_whitelist, 0);
2965
5/6
✓ Branch 0 taken 11 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 6 times.
✓ Branch 5 taken 1 times.
✓ Branch 6 taken 10 times.
 11 if (avcodec_open2(avctx, codec, (options && stream_index < orig_nb_streams) ? &options[stream_index] : &opts) < 0)
2966 1 av_log(ic, AV_LOG_WARNING,
2967 "Failed to open codec in %s\n", __func__);
2968 11 av_dict_free(&opts);
2969 }
2970 }
2971
2972 // EOF already reached while reading the stream above.
2973 // So continue with reoordering DTS with whatever delay we have.
2974
4/4
✓ Branch 0 taken 1731 times.
✓ Branch 1 taken 23 times.
✓ Branch 3 taken 21 times.
✓ Branch 4 taken 1710 times.
 1754 if (si->packet_buffer.head && !has_decode_delay_been_guessed(st)) {
2975 21 update_dts_from_pts(ic, stream_index, si->packet_buffer.head);
2976 }
2977 }
2978 }
2979
2980
2/2
✓ Branch 0 taken 4596 times.
✓ Branch 1 taken 3662 times.
 8258 if (flush_codecs) {
2981 4596 AVPacket *empty_pkt = si->pkt;
2982 4596 int err = 0;
2983 4596 av_packet_unref(empty_pkt);
2984
2985
2/2
✓ Branch 0 taken 4996 times.
✓ Branch 1 taken 4596 times.
 9592 for (unsigned i = 0; i < ic->nb_streams; i++) {
2986 4996 AVStream *const st = ic->streams[i];
2987 4996 FFStream *const sti = ffstream(st);
2988
2989 /* flush the decoders */
2990
2/2
✓ Branch 0 taken 4900 times.
✓ Branch 1 taken 96 times.
 4996 if (sti->info->found_decoder == 1) {
2991
2/2
✓ Branch 0 taken 4572 times.
✓ Branch 1 taken 328 times.
 9472 err = try_decode_frame(ic, st, empty_pkt,
2992
2/2
✓ Branch 0 taken 4556 times.
✓ Branch 1 taken 16 times.
 4572 (options && i < orig_nb_streams)
2993 4556 ? &options[i] : NULL);
2994
2995
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4900 times.
 4900 if (err < 0) {
2996 ✗ av_log(ic, AV_LOG_INFO,
2997 "decoding for stream %d failed\n", st->index);
2998 }
2999 }
3000 }
3001 }
3002
3003 8258 ff_rfps_calculate(ic);
3004
3005
2/2
✓ Branch 0 taken 9263 times.
✓ Branch 1 taken 8258 times.
 17521 for (unsigned i = 0; i < ic->nb_streams; i++) {
3006 9263 AVStream *const st = ic->streams[i];
3007 9263 FFStream *const sti = ffstream(st);
3008 9263 AVCodecContext *const avctx = sti->avctx;
3009
3010
2/2
✓ Branch 0 taken 6653 times.
✓ Branch 1 taken 2610 times.
 9263 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3011
6/6
✓ Branch 0 taken 650 times.
✓ Branch 1 taken 6003 times.
✓ Branch 2 taken 601 times.
✓ Branch 3 taken 49 times.
✓ Branch 4 taken 585 times.
✓ Branch 5 taken 16 times.
 6653 if (avctx->codec_id == AV_CODEC_ID_RAWVIDEO && !avctx->codec_tag && !avctx->bits_per_coded_sample) {
3012 585 uint32_t tag= avcodec_pix_fmt_to_codec_tag(avctx->pix_fmt);
3013
2/2
✓ Branch 1 taken 578 times.
✓ Branch 2 taken 7 times.
 585 if (avpriv_pix_fmt_find(PIX_FMT_LIST_RAW, tag) == avctx->pix_fmt)
3014 578 avctx->codec_tag= tag;
3015 }
3016
3017 /* estimate average framerate if not set by demuxer */
3018
2/2
✓ Branch 0 taken 4212 times.
✓ Branch 1 taken 2441 times.
 6653 if (sti->info->codec_info_duration_fields &&
3019
2/2
✓ Branch 0 taken 320 times.
✓ Branch 1 taken 3892 times.
 4212 !st->avg_frame_rate.num &&
3020
1/2
✓ Branch 0 taken 320 times.
✗ Branch 1 not taken.
 320 sti->info->codec_info_duration) {
3021 320 int best_fps = 0;
3022 320 double best_error = 0.01;
3023 320 AVRational codec_frame_rate = avctx->framerate;
3024
3025
1/2
✓ Branch 0 taken 320 times.
✗ Branch 1 not taken.
 320 if (sti->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3026
1/2
✓ Branch 0 taken 320 times.
✗ Branch 1 not taken.
 320 sti->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3027
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 320 times.
 320 sti->info->codec_info_duration < 0)
3028 ✗ continue;
3029 320 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3030 320 sti->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3031 320 sti->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3032
3033 /* Round guessed framerate to a "standard" framerate if it's
3034 * within 1% of the original estimate. */
3035
2/2
✓ Branch 0 taken 127680 times.
✓ Branch 1 taken 320 times.
 128000 for (int j = 0; j < MAX_STD_TIMEBASES; j++) {
3036 127680 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3037 127680 double error = fabs(av_q2d(st->avg_frame_rate) /
3038 127680 av_q2d(std_fps) - 1);
3039
3040
2/2
✓ Branch 0 taken 884 times.
✓ Branch 1 taken 126796 times.
 127680 if (error < best_error) {
3041 884 best_error = error;
3042 884 best_fps = std_fps.num;
3043 }
3044
3045
2/2
✓ Branch 1 taken 19551 times.
✓ Branch 2 taken 108129 times.
 127680 if ((ffifmt(ic->iformat)->flags_internal & FF_INFMT_FLAG_PREFER_CODEC_FRAMERATE) &&
3046
2/4
✓ Branch 0 taken 19551 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19551 times.
✗ Branch 3 not taken.
 19551 codec_frame_rate.num > 0 && codec_frame_rate.den > 0) {
3047 19551 error = fabs(av_q2d(codec_frame_rate) /
3048 19551 av_q2d(std_fps) - 1);
3049
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 19541 times.
 19551 if (error < best_error) {
3050 10 best_error = error;
3051 10 best_fps = std_fps.num;
3052 }
3053 }
3054 }
3055
2/2
✓ Branch 0 taken 317 times.
✓ Branch 1 taken 3 times.
 320 if (best_fps)
3056 317 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3057 best_fps, 12 * 1001, INT_MAX);
3058 }
3059
2/2
✓ Branch 0 taken 1942 times.
✓ Branch 1 taken 4711 times.
 6653 if (!st->r_frame_rate.num) {
3060 1942 const AVCodecDescriptor *desc = sti->codec_desc;
3061
3/4
✓ Branch 0 taken 1942 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 254 times.
✓ Branch 3 taken 1688 times.
 1942 AVRational mul = (AVRational){ desc && (desc->props & AV_CODEC_PROP_FIELDS) ? 2 : 1, 1 };
3062 1942 AVRational fr = av_mul_q(avctx->framerate, mul);
3063
3064
5/6
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 1742 times.
✓ Branch 2 taken 200 times.
✗ Branch 3 not taken.
✓ Branch 6 taken 186 times.
✓ Branch 7 taken 14 times.
 1942 if (fr.num && fr.den && av_cmp_q(st->time_base, av_inv_q(fr)) <= 0) {
3065 186 st->r_frame_rate = fr;
3066 } else {
3067 1756 st->r_frame_rate.num = st->time_base.den;
3068 1756 st->r_frame_rate.den = st->time_base.num;
3069 }
3070 }
3071 6653 st->codecpar->framerate = avctx->framerate;
3072
3/4
✓ Branch 0 taken 121 times.
✓ Branch 1 taken 6532 times.
✓ Branch 2 taken 121 times.
✗ Branch 3 not taken.
 6653 if (sti->display_aspect_ratio.num && sti->display_aspect_ratio.den) {
3073 121 AVRational hw_ratio = { avctx->height, avctx->width };
3074 121 st->sample_aspect_ratio = av_mul_q(sti->display_aspect_ratio,
3075 hw_ratio);
3076 }
3077
2/2
✓ Branch 0 taken 2402 times.
✓ Branch 1 taken 208 times.
 2610 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
3078
2/2
✓ Branch 0 taken 940 times.
✓ Branch 1 taken 1462 times.
 2402 if (!avctx->bits_per_coded_sample)
3079 940 avctx->bits_per_coded_sample =
3080 940 av_get_bits_per_sample(avctx->codec_id);
3081 // set stream disposition based on audio service type
3082
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 2402 times.
 2402 switch (avctx->audio_service_type) {
3083 ✗ case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3084 ✗ st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3085 ✗ break;
3086 ✗ case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3087 ✗ st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3088 ✗ break;
3089 ✗ case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3090 ✗ st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3091 ✗ break;
3092 ✗ case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3093 ✗ st->disposition = AV_DISPOSITION_COMMENT;
3094 ✗ break;
3095 ✗ case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3096 ✗ st->disposition = AV_DISPOSITION_KARAOKE;
3097 ✗ break;
3098 }
3099 }
3100 }
3101
3102
1/2
✓ Branch 0 taken 8258 times.
✗ Branch 1 not taken.
 8258 if (probesize)
3103 8258 estimate_timings(ic, old_offset);
3104
3105 8258 av_opt_set_int(ic, "skip_clear", 0, AV_OPT_SEARCH_CHILDREN);
3106
3107
4/4
✓ Branch 0 taken 6851 times.
✓ Branch 1 taken 1407 times.
✓ Branch 2 taken 6850 times.
✓ Branch 3 taken 1 times.
 8258 if (ret >= 0 && ic->nb_streams)
3108 /* We could not have all the codec parameters before EOF. */
3109 6850 ret = -1;
3110
2/2
✓ Branch 0 taken 9263 times.
✓ Branch 1 taken 8258 times.
 17521 for (unsigned i = 0; i < ic->nb_streams; i++) {
3111 9263 AVStream *const st = ic->streams[i];
3112 9263 FFStream *const sti = ffstream(st);
3113 const char *errmsg;
3114
3115 /* if no packet was ever seen, update context now for has_codec_parameters */
3116
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 9248 times.
 9263 if (!sti->avctx_inited) {
3117
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 5 times.
 15 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
3118
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
 10 st->codecpar->format == AV_SAMPLE_FMT_NONE)
3119 10 st->codecpar->format = sti->avctx->sample_fmt;
3120 15 ret = avcodec_parameters_to_context(sti->avctx, st->codecpar);
3121
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 if (ret < 0)
3122 ✗ goto find_stream_info_err;
3123 }
3124
2/2
✓ Branch 1 taken 39 times.
✓ Branch 2 taken 9224 times.
 9263 if (!has_codec_parameters(st, &errmsg)) {
3125 char buf[256];
3126 39 avcodec_string(buf, sizeof(buf), sti->avctx, 0);
3127 39 av_log(ic, AV_LOG_WARNING,
3128 "Could not find codec parameters for stream %d (%s): %s\n"
3129 "Consider increasing the value for the 'analyzeduration' (%"PRId64") and 'probesize' (%"PRId64") options\n",
3130 i, buf, errmsg, ic->max_analyze_duration, ic->probesize);
3131 } else {
3132 9224 ret = 0;
3133 }
3134 }
3135
3136 8258 err = compute_chapters_end(ic);
3137
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8258 times.
 8258 if (err < 0) {
3138 ✗ ret = err;
3139 ✗ goto find_stream_info_err;
3140 }
3141
3142 /* update the stream parameters from the internal codec contexts */
3143
2/2
✓ Branch 0 taken 9263 times.
✓ Branch 1 taken 8258 times.
 17521 for (unsigned i = 0; i < ic->nb_streams; i++) {
3144 9263 AVStream *const st = ic->streams[i];
3145 9263 FFStream *const sti = ffstream(st);
3146
3147
2/2
✓ Branch 0 taken 9248 times.
✓ Branch 1 taken 15 times.
 9263 if (sti->avctx_inited) {
3148 9248 ret = parameters_from_context(ic, st->codecpar, sti->avctx);
3149
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9248 times.
 9248 if (ret < 0)
3150 ✗ goto find_stream_info_err;
3151
3152
3/4
✓ Branch 0 taken 9031 times.
✓ Branch 1 taken 217 times.
✓ Branch 2 taken 9031 times.
✗ Branch 3 not taken.
 9248 if (sti->avctx->rc_buffer_size > 0 || sti->avctx->rc_max_rate > 0 ||
3153
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9031 times.
 9031 sti->avctx->rc_min_rate) {
3154 size_t cpb_size;
3155 217 AVCPBProperties *props = av_cpb_properties_alloc(&cpb_size);
3156
1/2
✓ Branch 0 taken 217 times.
✗ Branch 1 not taken.
 217 if (props) {
3157
1/2
✓ Branch 0 taken 217 times.
✗ Branch 1 not taken.
 217 if (sti->avctx->rc_buffer_size > 0)
3158 217 props->buffer_size = sti->avctx->rc_buffer_size;
3159
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 217 times.
 217 if (sti->avctx->rc_min_rate > 0)
3160 ✗ props->min_bitrate = sti->avctx->rc_min_rate;
3161
2/2
✓ Branch 0 taken 79 times.
✓ Branch 1 taken 138 times.
 217 if (sti->avctx->rc_max_rate > 0)
3162 79 props->max_bitrate = sti->avctx->rc_max_rate;
3163
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 217 times.
 217 if (!av_packet_side_data_add(&st->codecpar->coded_side_data,
3164 217 &st->codecpar->nb_coded_side_data,
3165 AV_PKT_DATA_CPB_PROPERTIES,
3166 (uint8_t *)props, cpb_size, 0))
3167 ✗ av_free(props);
3168 }
3169 }
3170 }
3171
3172 9263 sti->avctx_inited = 0;
3173 }
3174
3175 /* update the stream group parameters from the stream contexts if needed */
3176
2/2
✓ Branch 0 taken 140 times.
✓ Branch 1 taken 8258 times.
 8398 for (unsigned i = 0; i < ic->nb_stream_groups; i++) {
3177 140 AVStreamGroup *const stg = ic->stream_groups[i];
3178 AVStreamGroupLayeredVideo *lcevc;
3179 const AVStream *st;
3180
3181
2/2
✓ Branch 0 taken 134 times.
✓ Branch 1 taken 6 times.
 140 if (stg->type != AV_STREAM_GROUP_PARAMS_LCEVC)
3182 134 continue;
3183
3184 /* For LCEVC in mpegts, the parser is needed to get the enhancement layer
3185 * dimensions */
3186 6 lcevc = stg->params.layered_video;
3187
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)
3188 ✗ continue;
3189 6 st = stg->streams[lcevc->el_index];
3190 6 lcevc->width = st->codecpar->width;
3191 6 lcevc->height = st->codecpar->height;
3192 }
3193
3194 8258 find_stream_info_err:
3195
2/2
✓ Branch 0 taken 9263 times.
✓ Branch 1 taken 8258 times.
 17521 for (unsigned i = 0; i < ic->nb_streams; i++) {
3196 9263 AVStream *const st = ic->streams[i];
3197 9263 FFStream *const sti = ffstream(st);
3198 int err;
3199
3200
1/2
✓ Branch 0 taken 9263 times.
✗ Branch 1 not taken.
 9263 if (sti->info) {
3201 9263 av_freep(&sti->info->duration_error);
3202 9263 av_freep(&sti->info);
3203 }
3204
3205
2/2
✓ Branch 1 taken 9123 times.
✓ Branch 2 taken 140 times.
 9263 if (avcodec_is_open(sti->avctx)) {
3206 9123 err = codec_close(sti);
3207
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 9123 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 9123 if (err < 0 && ret >= 0)
3208 ✗ ret = err;
3209 }
3210
3211 9263 av_bsf_free(&sti->extract_extradata.bsf);
3212 }
3213
2/2
✓ Branch 0 taken 5060 times.
✓ Branch 1 taken 3198 times.
 8258 if (ic->pb) {
3214 5060 FFIOContext *const ctx = ffiocontext(ic->pb);
3215 5060 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3216 avio_tell(ic->pb), ctx->bytes_read, ctx->seek_count, count);
3217 }
3218 8258 return ret;
3219
3220 ✗ unref_then_goto_end:
3221 ✗ av_packet_unref(pkt1);
3222 ✗ goto find_stream_info_err;
3223 }
3224