FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/fftools/ffmpeg_dec.c
Date: 2026-01-23 19:11:46
Exec Total Coverage
Lines: 666 950 70.1%
Functions: 31 32 96.9%
Branches: 384 615 62.4%
Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <stdbit.h>
20
21 #include "libavutil/avassert.h"
22 #include "libavutil/avstring.h"
23 #include "libavutil/dict.h"
24 #include "libavutil/error.h"
25 #include "libavutil/log.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/pixfmt.h"
30 #include "libavutil/stereo3d.h"
31 #include "libavutil/time.h"
32 #include "libavutil/timestamp.h"
33
34 #include "libavcodec/avcodec.h"
35 #include "libavcodec/codec.h"
36
37 #include "ffmpeg.h"
38
39 typedef struct DecoderPriv {
40 Decoder dec;
41
42 AVCodecContext *dec_ctx;
43
44 AVFrame *frame;
45 AVFrame *frame_tmp_ref;
46 AVPacket *pkt;
47
48 // override output video sample aspect ratio with this value
49 AVRational sar_override;
50
51 AVRational framerate_in;
52
53 // a combination of DECODER_FLAG_*, provided to dec_open()
54 int flags;
55 int apply_cropping;
56
57 enum AVPixelFormat hwaccel_pix_fmt;
58 enum HWAccelID hwaccel_id;
59 enum AVHWDeviceType hwaccel_device_type;
60 enum AVPixelFormat hwaccel_output_format;
61
62 // pts/estimated duration of the last decoded frame
63 // * in decoder timebase for video,
64 // * in last_frame_tb (may change during decoding) for audio
65 int64_t last_frame_pts;
66 int64_t last_frame_duration_est;
67 AVRational last_frame_tb;
68 int64_t last_filter_in_rescale_delta;
69 int last_frame_sample_rate;
70
71 /* previous decoded subtitles */
72 AVFrame *sub_prev[2];
73 AVFrame *sub_heartbeat;
74
75 Scheduler *sch;
76 unsigned sch_idx;
77
78 // this decoder's index in decoders or -1
79 int index;
80 void *log_parent;
81 char log_name[32];
82 char *parent_name;
83
84 // user specified decoder multiview options manually
85 int multiview_user_config;
86
87 struct {
88 ViewSpecifier vs;
89 unsigned out_idx;
90 } *views_requested;
91 int nb_views_requested;
92
93 /* A map of view ID to decoder outputs.
94 * MUST NOT be accessed outside of get_format()/get_buffer() */
95 struct {
96 unsigned id;
97 uintptr_t out_mask;
98 } *view_map;
99 int nb_view_map;
100
101 struct {
102 AVDictionary *opts;
103 const AVCodec *codec;
104 } standalone_init;
105 } DecoderPriv;
106
107 12637 static DecoderPriv *dp_from_dec(Decoder *d)
108 {
109 12637 return (DecoderPriv*)d;
110 }
111
112 // data that is local to the decoder thread and not visible outside of it
113 typedef struct DecThreadContext {
114 AVFrame *frame;
115 AVPacket *pkt;
116 } DecThreadContext;
117
118 7977 void dec_free(Decoder **pdec)
119 {
120 7977 Decoder *dec = *pdec;
121 DecoderPriv *dp;
122
123
2/2
✓ Branch 0 taken 1031 times.
✓ Branch 1 taken 6946 times.
 7977 if (!dec)
124 1031 return;
125 6946 dp = dp_from_dec(dec);
126
127 6946 avcodec_free_context(&dp->dec_ctx);
128
129 6946 av_frame_free(&dp->frame);
130 6946 av_frame_free(&dp->frame_tmp_ref);
131 6946 av_packet_free(&dp->pkt);
132
133 6946 av_dict_free(&dp->standalone_init.opts);
134
135
2/2
✓ Branch 0 taken 13892 times.
✓ Branch 1 taken 6946 times.
 20838 for (int i = 0; i < FF_ARRAY_ELEMS(dp->sub_prev); i++)
136 13892 av_frame_free(&dp->sub_prev[i]);
137 6946 av_frame_free(&dp->sub_heartbeat);
138
139 6946 av_freep(&dp->parent_name);
140
141 6946 av_freep(&dp->views_requested);
142 6946 av_freep(&dp->view_map);
143
144 6946 av_freep(pdec);
145 }
146
147 572 static const char *dec_item_name(void *obj)
148 {
149 572 const DecoderPriv *dp = obj;
150
151 572 return dp->log_name;
152 }
153
154 static const AVClass dec_class = {
155 .class_name = "Decoder",
156 .version = LIBAVUTIL_VERSION_INT,
157 .parent_log_context_offset = offsetof(DecoderPriv, log_parent),
158 .item_name = dec_item_name,
159 };
160
161 static int decoder_thread(void *arg);
162
163 6946 static int dec_alloc(DecoderPriv **pdec, Scheduler *sch, int send_end_ts)
164 {
165 DecoderPriv *dp;
166 6946 int ret = 0;
167
168 6946 *pdec = NULL;
169
170 6946 dp = av_mallocz(sizeof(*dp));
171
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (!dp)
172 ✗ return AVERROR(ENOMEM);
173
174 6946 dp->frame = av_frame_alloc();
175
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (!dp->frame)
176 ✗ goto fail;
177
178 6946 dp->pkt = av_packet_alloc();
179
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (!dp->pkt)
180 ✗ goto fail;
181
182 6946 dp->index = -1;
183 6946 dp->dec.class = &dec_class;
184 6946 dp->last_filter_in_rescale_delta = AV_NOPTS_VALUE;
185 6946 dp->last_frame_pts = AV_NOPTS_VALUE;
186 6946 dp->last_frame_tb = (AVRational){ 1, 1 };
187 6946 dp->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
188
189 6946 ret = sch_add_dec(sch, decoder_thread, dp, send_end_ts);
190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (ret < 0)
191 ✗ goto fail;
192 6946 dp->sch = sch;
193 6946 dp->sch_idx = ret;
194
195 6946 *pdec = dp;
196
197 6946 return 0;
198 ✗ fail:
199 ✗ dec_free((Decoder**)&dp);
200 ✗ return ret >= 0 ? AVERROR(ENOMEM) : ret;
201 }
202
203 260697 static AVRational audio_samplerate_update(DecoderPriv *dp,
204 const AVFrame *frame)
205 {
206 260697 const int prev = dp->last_frame_tb.den;
207 260697 const int sr = frame->sample_rate;
208
209 AVRational tb_new;
210 int64_t gcd;
211
212
2/2
✓ Branch 0 taken 259478 times.
✓ Branch 1 taken 1219 times.
 260697 if (frame->sample_rate == dp->last_frame_sample_rate)
213 259478 goto finish;
214
215 1219 gcd = av_gcd(prev, sr);
216
217
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1219 times.
 1219 if (prev / gcd >= INT_MAX / sr) {
218 ✗ av_log(dp, AV_LOG_WARNING,
219 "Audio timestamps cannot be represented exactly after "
220 "sample rate change: %d -> %d\n", prev, sr);
221
222 // LCM of 192000, 44100, allows to represent all common samplerates
223 ✗ tb_new = (AVRational){ 1, 28224000 };
224 } else
225 1219 tb_new = (AVRational){ 1, prev / gcd * sr };
226
227 // keep the frame timebase if it is strictly better than
228 // the samplerate-defined one
229
4/4
✓ Branch 0 taken 1203 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 105 times.
✓ Branch 3 taken 1098 times.
 1219 if (frame->time_base.num == 1 && frame->time_base.den > tb_new.den &&
230
2/2
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 65 times.
 105 !(frame->time_base.den % tb_new.den))
231 40 tb_new = frame->time_base;
232
233
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1219 times.
 1219 if (dp->last_frame_pts != AV_NOPTS_VALUE)
234 ✗ dp->last_frame_pts = av_rescale_q(dp->last_frame_pts,
235 dp->last_frame_tb, tb_new);
236 1219 dp->last_frame_duration_est = av_rescale_q(dp->last_frame_duration_est,
237 dp->last_frame_tb, tb_new);
238
239 1219 dp->last_frame_tb = tb_new;
240 1219 dp->last_frame_sample_rate = frame->sample_rate;
241
242 260697 finish:
243 260697 return dp->last_frame_tb;
244 }
245
246 260697 static void audio_ts_process(DecoderPriv *dp, AVFrame *frame)
247 {
248 260697 AVRational tb_filter = (AVRational){1, frame->sample_rate};
249 AVRational tb;
250 int64_t pts_pred;
251
252 // on samplerate change, choose a new internal timebase for timestamp
253 // generation that can represent timestamps from all the samplerates
254 // seen so far
255 260697 tb = audio_samplerate_update(dp, frame);
256
2/2
✓ Branch 0 taken 259478 times.
✓ Branch 1 taken 1219 times.
 260697 pts_pred = dp->last_frame_pts == AV_NOPTS_VALUE ? 0 :
257 259478 dp->last_frame_pts + dp->last_frame_duration_est;
258
259
2/2
✓ Branch 0 taken 51552 times.
✓ Branch 1 taken 209145 times.
 260697 if (frame->pts == AV_NOPTS_VALUE) {
260 51552 frame->pts = pts_pred;
261 51552 frame->time_base = tb;
262
2/2
✓ Branch 0 taken 207999 times.
✓ Branch 1 taken 1146 times.
 209145 } else if (dp->last_frame_pts != AV_NOPTS_VALUE &&
263
2/2
✓ Branch 0 taken 610 times.
✓ Branch 1 taken 207389 times.
 207999 frame->pts > av_rescale_q_rnd(pts_pred, tb, frame->time_base,
264 AV_ROUND_UP)) {
265 // there was a gap in timestamps, reset conversion state
266 610 dp->last_filter_in_rescale_delta = AV_NOPTS_VALUE;
267 }
268
269 260697 frame->pts = av_rescale_delta(frame->time_base, frame->pts,
270 tb, frame->nb_samples,
271 &dp->last_filter_in_rescale_delta, tb);
272
273 260697 dp->last_frame_pts = frame->pts;
274 260697 dp->last_frame_duration_est = av_rescale_q(frame->nb_samples,
275 tb_filter, tb);
276
277 // finally convert to filtering timebase
278 260697 frame->pts = av_rescale_q(frame->pts, tb, tb_filter);
279 260697 frame->duration = frame->nb_samples;
280 260697 frame->time_base = tb_filter;
281 260697 }
282
283 126419 static int64_t video_duration_estimate(const DecoderPriv *dp, const AVFrame *frame)
284 {
285 126419 const int ts_unreliable = dp->flags & DECODER_FLAG_TS_UNRELIABLE;
286 126419 const int fr_forced = dp->flags & DECODER_FLAG_FRAMERATE_FORCED;
287 126419 int64_t codec_duration = 0;
288 // difference between this and last frame's timestamps
289 126419 const int64_t ts_diff =
290
2/2
✓ Branch 0 taken 120739 times.
✓ Branch 1 taken 5680 times.
 126419 (frame->pts != AV_NOPTS_VALUE && dp->last_frame_pts != AV_NOPTS_VALUE) ?
291
1/2
✓ Branch 0 taken 126419 times.
✗ Branch 1 not taken.
 252838 frame->pts - dp->last_frame_pts : -1;
292
293 // XXX lavf currently makes up frame durations when they are not provided by
294 // the container. As there is no way to reliably distinguish real container
295 // durations from the fake made-up ones, we use heuristics based on whether
296 // the container has timestamps. Eventually lavf should stop making up
297 // durations, then this should be simplified.
298
299 // frame duration is unreliable (typically guessed by lavf) when it is equal
300 // to 1 and the actual duration of the last frame is more than 2x larger
301
4/4
✓ Branch 0 taken 91704 times.
✓ Branch 1 taken 34715 times.
✓ Branch 2 taken 17059 times.
✓ Branch 3 taken 74645 times.
 126419 const int duration_unreliable = frame->duration == 1 && ts_diff > 2 * frame->duration;
302
303 // prefer frame duration for containers with timestamps
304
2/2
✓ Branch 0 taken 126200 times.
✓ Branch 1 taken 219 times.
 126419 if (fr_forced ||
305
6/6
✓ Branch 0 taken 124567 times.
✓ Branch 1 taken 1633 times.
✓ Branch 2 taken 90294 times.
✓ Branch 3 taken 34273 times.
✓ Branch 4 taken 89699 times.
✓ Branch 5 taken 595 times.
 126200 (frame->duration > 0 && !ts_unreliable && !duration_unreliable))
306 89918 return frame->duration;
307
308
3/4
✓ Branch 0 taken 36501 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5805 times.
✓ Branch 3 taken 30696 times.
 36501 if (dp->dec_ctx->framerate.den && dp->dec_ctx->framerate.num) {
309 5805 int fields = frame->repeat_pict + 2;
310 5805 AVRational field_rate = av_mul_q(dp->dec_ctx->framerate,
311 5805 (AVRational){ 2, 1 });
312 5805 codec_duration = av_rescale_q(fields, av_inv_q(field_rate),
313 frame->time_base);
314 }
315
316 // prefer codec-layer duration for containers without timestamps
317
4/4
✓ Branch 0 taken 5805 times.
✓ Branch 1 taken 30696 times.
✓ Branch 2 taken 5786 times.
✓ Branch 3 taken 19 times.
 36501 if (codec_duration > 0 && ts_unreliable)
318 5786 return codec_duration;
319
320 // when timestamps are available, repeat last frame's actual duration
321 // (i.e. pts difference between this and last frame)
322
2/2
✓ Branch 0 taken 30191 times.
✓ Branch 1 taken 524 times.
 30715 if (ts_diff > 0)
323 30191 return ts_diff;
324
325 // try frame/codec duration
326
2/2
✓ Branch 0 taken 455 times.
✓ Branch 1 taken 69 times.
 524 if (frame->duration > 0)
327 455 return frame->duration;
328
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (codec_duration > 0)
329 ✗ return codec_duration;
330
331 // try average framerate
332
3/4
✓ Branch 0 taken 43 times.
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 43 times.
✗ Branch 3 not taken.
 69 if (dp->framerate_in.num && dp->framerate_in.den) {
333 43 int64_t d = av_rescale_q(1, av_inv_q(dp->framerate_in),
334 frame->time_base);
335
1/2
✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
 43 if (d > 0)
336 43 return d;
337 }
338
339 // last resort is last frame's estimated duration, and 1
340 26 return FFMAX(dp->last_frame_duration_est, 1);
341 }
342
343 ✗ static int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
344 {
345 ✗ DecoderPriv *dp = avctx->opaque;
346 ✗ AVFrame *output = NULL;
347 ✗ enum AVPixelFormat output_format = dp->hwaccel_output_format;
348 int err;
349
350 ✗ if (input->format == output_format) {
351 // Nothing to do.
352 ✗ return 0;
353 }
354
355 ✗ output = av_frame_alloc();
356 ✗ if (!output)
357 ✗ return AVERROR(ENOMEM);
358
359 ✗ output->format = output_format;
360
361 ✗ err = av_hwframe_transfer_data(output, input, 0);
362 ✗ if (err < 0) {
363 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to transfer data to "
364 "output frame: %d.\n", err);
365 ✗ goto fail;
366 }
367
368 ✗ err = av_frame_copy_props(output, input);
369 ✗ if (err < 0) {
370 ✗ av_frame_unref(output);
371 ✗ goto fail;
372 }
373
374 ✗ av_frame_unref(input);
375 ✗ av_frame_move_ref(input, output);
376 ✗ av_frame_free(&output);
377
378 ✗ return 0;
379
380 ✗ fail:
381 ✗ av_frame_free(&output);
382 ✗ return err;
383 }
384
385 126419 static int video_frame_process(DecoderPriv *dp, AVFrame *frame,
386 unsigned *outputs_mask)
387 {
388 #if FFMPEG_OPT_TOP
389
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126419 times.
 126419 if (dp->flags & DECODER_FLAG_TOP_FIELD_FIRST) {
390 ✗ av_log(dp, AV_LOG_WARNING, "-top is deprecated, use the setfield filter instead\n");
391 ✗ frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
392 }
393 #endif
394
395
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126419 times.
 126419 if (frame->format == dp->hwaccel_pix_fmt) {
396 ✗ int err = hwaccel_retrieve_data(dp->dec_ctx, frame);
397 ✗ if (err < 0)
398 ✗ return err;
399 }
400
401 126419 frame->pts = frame->best_effort_timestamp;
402
403 // forced fixed framerate
404
2/2
✓ Branch 0 taken 219 times.
✓ Branch 1 taken 126200 times.
 126419 if (dp->flags & DECODER_FLAG_FRAMERATE_FORCED) {
405 219 frame->pts = AV_NOPTS_VALUE;
406 219 frame->duration = 1;
407 219 frame->time_base = av_inv_q(dp->framerate_in);
408 }
409
410 // no timestamp available - extrapolate from previous frame duration
411
2/2
✓ Branch 0 taken 34553 times.
✓ Branch 1 taken 91866 times.
 126419 if (frame->pts == AV_NOPTS_VALUE)
412
2/2
✓ Branch 0 taken 33983 times.
✓ Branch 1 taken 570 times.
 68536 frame->pts = dp->last_frame_pts == AV_NOPTS_VALUE ? 0 :
413 33983 dp->last_frame_pts + dp->last_frame_duration_est;
414
415 // update timestamp history
416 126419 dp->last_frame_duration_est = video_duration_estimate(dp, frame);
417 126419 dp->last_frame_pts = frame->pts;
418 126419 dp->last_frame_tb = frame->time_base;
419
420
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126419 times.
 126419 if (debug_ts) {
421 ✗ av_log(dp, AV_LOG_INFO,
422 "decoder -> pts:%s pts_time:%s "
423 "pkt_dts:%s pkt_dts_time:%s "
424 "duration:%s duration_time:%s "
425 "keyframe:%d frame_type:%d time_base:%d/%d\n",
426 ✗ av_ts2str(frame->pts),
427 ✗ av_ts2timestr(frame->pts, &frame->time_base),
428 ✗ av_ts2str(frame->pkt_dts),
429 ✗ av_ts2timestr(frame->pkt_dts, &frame->time_base),
430 ✗ av_ts2str(frame->duration),
431 ✗ av_ts2timestr(frame->duration, &frame->time_base),
432 ✗ !!(frame->flags & AV_FRAME_FLAG_KEY), frame->pict_type,
433 frame->time_base.num, frame->time_base.den);
434 }
435
436
2/2
✓ Branch 0 taken 15385 times.
✓ Branch 1 taken 111034 times.
 126419 if (dp->sar_override.num)
437 15385 frame->sample_aspect_ratio = dp->sar_override;
438
439
2/2
✓ Branch 0 taken 126418 times.
✓ Branch 1 taken 1 times.
 126419 if (dp->apply_cropping) {
440 // lavfi does not require aligned frame data
441 126418 int ret = av_frame_apply_cropping(frame, AV_FRAME_CROP_UNALIGNED);
442
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126418 times.
 126418 if (ret < 0) {
443 ✗ av_log(dp, AV_LOG_ERROR, "Error applying decoder cropping\n");
444 ✗ return ret;
445 }
446 }
447
448
2/2
✓ Branch 0 taken 673 times.
✓ Branch 1 taken 125746 times.
 126419 if (frame->opaque)
449 673 *outputs_mask = (uintptr_t)frame->opaque;
450
451 126419 return 0;
452 }
453
454 1 static int copy_av_subtitle(AVSubtitle *dst, const AVSubtitle *src)
455 {
456 1 int ret = AVERROR_BUG;
457 1 AVSubtitle tmp = {
458 1 .format = src->format,
459 1 .start_display_time = src->start_display_time,
460 1 .end_display_time = src->end_display_time,
461 .num_rects = 0,
462 .rects = NULL,
463 1 .pts = src->pts
464 };
465
466
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!src->num_rects)
467 ✗ goto success;
468
469
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (!(tmp.rects = av_calloc(src->num_rects, sizeof(*tmp.rects))))
470 ✗ return AVERROR(ENOMEM);
471
472
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 for (int i = 0; i < src->num_rects; i++) {
473 1 AVSubtitleRect *src_rect = src->rects[i];
474 AVSubtitleRect *dst_rect;
475
476
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (!(dst_rect = tmp.rects[i] = av_mallocz(sizeof(*tmp.rects[0])))) {
477 ✗ ret = AVERROR(ENOMEM);
478 ✗ goto cleanup;
479 }
480
481 1 tmp.num_rects++;
482
483 1 dst_rect->type = src_rect->type;
484 1 dst_rect->flags = src_rect->flags;
485
486 1 dst_rect->x = src_rect->x;
487 1 dst_rect->y = src_rect->y;
488 1 dst_rect->w = src_rect->w;
489 1 dst_rect->h = src_rect->h;
490 1 dst_rect->nb_colors = src_rect->nb_colors;
491
492
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (src_rect->text)
493 ✗ if (!(dst_rect->text = av_strdup(src_rect->text))) {
494 ✗ ret = AVERROR(ENOMEM);
495 ✗ goto cleanup;
496 }
497
498
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (src_rect->ass)
499
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (!(dst_rect->ass = av_strdup(src_rect->ass))) {
500 ✗ ret = AVERROR(ENOMEM);
501 ✗ goto cleanup;
502 }
503
504
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1 times.
 5 for (int j = 0; j < 4; j++) {
505 // SUBTITLE_BITMAP images are special in the sense that they
506 // are like PAL8 images. first pointer to data, second to
507 // palette. This makes the size calculation match this.
508 ✗ size_t buf_size = src_rect->type == SUBTITLE_BITMAP && j == 1 ?
509
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 AVPALETTE_SIZE :
510 4 src_rect->h * src_rect->linesize[j];
511
512
1/2
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
 4 if (!src_rect->data[j])
513 4 continue;
514
515 ✗ if (!(dst_rect->data[j] = av_memdup(src_rect->data[j], buf_size))) {
516 ✗ ret = AVERROR(ENOMEM);
517 ✗ goto cleanup;
518 }
519 ✗ dst_rect->linesize[j] = src_rect->linesize[j];
520 }
521 }
522
523 1 success:
524 1 *dst = tmp;
525
526 1 return 0;
527
528 ✗ cleanup:
529 ✗ avsubtitle_free(&tmp);
530
531 ✗ return ret;
532 }
533
534 994 static void subtitle_free(void *opaque, uint8_t *data)
535 {
536 994 AVSubtitle *sub = (AVSubtitle*)data;
537 994 avsubtitle_free(sub);
538 994 av_free(sub);
539 994 }
540
541 994 static int subtitle_wrap_frame(AVFrame *frame, AVSubtitle *subtitle, int copy)
542 {
543 AVBufferRef *buf;
544 AVSubtitle *sub;
545 int ret;
546
547
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 993 times.
 994 if (copy) {
548 1 sub = av_mallocz(sizeof(*sub));
549
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 ret = sub ? copy_av_subtitle(sub, subtitle) : AVERROR(ENOMEM);
550
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0) {
551 ✗ av_freep(&sub);
552 ✗ return ret;
553 }
554 } else {
555 993 sub = av_memdup(subtitle, sizeof(*subtitle));
556
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 993 times.
 993 if (!sub)
557 ✗ return AVERROR(ENOMEM);
558 993 memset(subtitle, 0, sizeof(*subtitle));
559 }
560
561 994 buf = av_buffer_create((uint8_t*)sub, sizeof(*sub),
562 subtitle_free, NULL, 0);
563
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 994 times.
 994 if (!buf) {
564 ✗ avsubtitle_free(sub);
565 ✗ av_freep(&sub);
566 ✗ return AVERROR(ENOMEM);
567 }
568
569 994 frame->buf[0] = buf;
570
571 994 return 0;
572 }
573
574 994 static int process_subtitle(DecoderPriv *dp, AVFrame *frame)
575 {
576 994 const AVSubtitle *subtitle = (AVSubtitle*)frame->buf[0]->data;
577 994 int ret = 0;
578
579
2/2
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 977 times.
 994 if (dp->flags & DECODER_FLAG_FIX_SUB_DURATION) {
580 34 AVSubtitle *sub_prev = dp->sub_prev[0]->buf[0] ?
581
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 2 times.
 17 (AVSubtitle*)dp->sub_prev[0]->buf[0]->data : NULL;
582 17 int end = 1;
583
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 2 times.
 17 if (sub_prev) {
584 15 end = av_rescale(subtitle->pts - sub_prev->pts,
585 1000, AV_TIME_BASE);
586
1/2
✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
 15 if (end < sub_prev->end_display_time) {
587
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15 times.
 15 av_log(dp, AV_LOG_DEBUG,
588 "Subtitle duration reduced from %"PRId32" to %d%s\n",
589 sub_prev->end_display_time, end,
590 end <= 0 ? ", dropping it" : "");
591 15 sub_prev->end_display_time = end;
592 }
593 }
594
595 17 av_frame_unref(dp->sub_prev[1]);
596 17 av_frame_move_ref(dp->sub_prev[1], frame);
597
598 17 frame = dp->sub_prev[0];
599
2/2
✓ Branch 0 taken 15 times.
✓ Branch 1 taken 2 times.
 17 subtitle = frame->buf[0] ? (AVSubtitle*)frame->buf[0]->data : NULL;
600
601 17 FFSWAP(AVFrame*, dp->sub_prev[0], dp->sub_prev[1]);
602
603
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17 times.
 17 if (end <= 0)
604 ✗ return 0;
605 }
606
607
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 992 times.
 994 if (!subtitle)
608 2 return 0;
609
610 992 ret = sch_dec_send(dp->sch, dp->sch_idx, 0, frame);
611
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 992 times.
 992 if (ret < 0)
612 ✗ av_frame_unref(frame);
613
614
1/2
✓ Branch 0 taken 992 times.
✗ Branch 1 not taken.
 992 return ret == AVERROR_EOF ? AVERROR_EXIT : ret;
615 }
616
617 4 static int fix_sub_duration_heartbeat(DecoderPriv *dp, int64_t signal_pts)
618 {
619 4 int ret = AVERROR_BUG;
620 8 AVSubtitle *prev_subtitle = dp->sub_prev[0]->buf[0] ?
621
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
 4 (AVSubtitle*)dp->sub_prev[0]->buf[0]->data : NULL;
622 AVSubtitle *subtitle;
623
624
3/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 1 times.
 4 if (!(dp->flags & DECODER_FLAG_FIX_SUB_DURATION) || !prev_subtitle ||
625
3/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
 3 !prev_subtitle->num_rects || signal_pts <= prev_subtitle->pts)
626 3 return 0;
627
628 1 av_frame_unref(dp->sub_heartbeat);
629 1 ret = subtitle_wrap_frame(dp->sub_heartbeat, prev_subtitle, 1);
630
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
631 ✗ return ret;
632
633 1 subtitle = (AVSubtitle*)dp->sub_heartbeat->buf[0]->data;
634 1 subtitle->pts = signal_pts;
635
636 1 return process_subtitle(dp, dp->sub_heartbeat);
637 }
638
639 2818 static int transcode_subtitles(DecoderPriv *dp, const AVPacket *pkt,
640 AVFrame *frame)
641 {
642 2818 AVPacket *flush_pkt = NULL;
643 AVSubtitle subtitle;
644 int got_output;
645 int ret;
646
647
4/4
✓ Branch 0 taken 2774 times.
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 948 times.
✓ Branch 3 taken 1826 times.
 2818 if (pkt && (intptr_t)pkt->opaque == PKT_OPAQUE_SUB_HEARTBEAT) {
648 948 frame->pts = pkt->pts;
649 948 frame->time_base = pkt->time_base;
650 948 frame->opaque = (void*)(intptr_t)FRAME_OPAQUE_SUB_HEARTBEAT;
651
652 948 ret = sch_dec_send(dp->sch, dp->sch_idx, 0, frame);
653
1/2
✓ Branch 0 taken 948 times.
✗ Branch 1 not taken.
 948 return ret == AVERROR_EOF ? AVERROR_EXIT : ret;
654
4/4
✓ Branch 0 taken 1826 times.
✓ Branch 1 taken 44 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 1822 times.
 1870 } else if (pkt && (intptr_t)pkt->opaque == PKT_OPAQUE_FIX_SUB_DURATION) {
655 4 return fix_sub_duration_heartbeat(dp, av_rescale_q(pkt->pts, pkt->time_base,
656 4 AV_TIME_BASE_Q));
657 }
658
659
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 1822 times.
 1866 if (!pkt) {
660 44 flush_pkt = av_packet_alloc();
661
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 44 times.
 44 if (!flush_pkt)
662 ✗ return AVERROR(ENOMEM);
663 }
664
665
2/2
✓ Branch 0 taken 1822 times.
✓ Branch 1 taken 44 times.
 1866 ret = avcodec_decode_subtitle2(dp->dec_ctx, &subtitle, &got_output,
666 pkt ? pkt : flush_pkt);
667 1866 av_packet_free(&flush_pkt);
668
669
2/2
✓ Branch 0 taken 79 times.
✓ Branch 1 taken 1787 times.
 1866 if (ret < 0) {
670 79 av_log(dp, AV_LOG_ERROR, "Error decoding subtitles: %s\n",
671 79 av_err2str(ret));
672 79 dp->dec.decode_errors++;
673
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 79 times.
 79 return exit_on_error ? ret : 0;
674 }
675
676
2/2
✓ Branch 0 taken 794 times.
✓ Branch 1 taken 993 times.
 1787 if (!got_output)
677
2/2
✓ Branch 0 taken 750 times.
✓ Branch 1 taken 44 times.
 794 return pkt ? 0 : AVERROR_EOF;
678
679 993 dp->dec.frames_decoded++;
680
681 // XXX the queue for transferring data to consumers runs
682 // on AVFrames, so we wrap AVSubtitle in an AVBufferRef and put that
683 // inside the frame
684 // eventually, subtitles should be switched to use AVFrames natively
685 993 ret = subtitle_wrap_frame(frame, &subtitle, 0);
686
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 993 times.
 993 if (ret < 0) {
687 ✗ avsubtitle_free(&subtitle);
688 ✗ return ret;
689 }
690
691 993 frame->width = dp->dec_ctx->width;
692 993 frame->height = dp->dec_ctx->height;
693
694 993 return process_subtitle(dp, frame);
695 }
696
697 371160 static int packet_decode(DecoderPriv *dp, AVPacket *pkt, AVFrame *frame)
698 {
699 371160 AVCodecContext *dec = dp->dec_ctx;
700 371160 const char *type_desc = av_get_media_type_string(dec->codec_type);
701 int ret;
702
703
2/2
✓ Branch 0 taken 2818 times.
✓ Branch 1 taken 368342 times.
 371160 if (dec->codec_type == AVMEDIA_TYPE_SUBTITLE)
704 2818 return transcode_subtitles(dp, pkt, frame);
705
706 // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
707 // reason. This seems like a semi-critical bug. Don't trigger EOF, and
708 // skip the packet.
709
4/4
✓ Branch 0 taken 364984 times.
✓ Branch 1 taken 3358 times.
✓ Branch 2 taken 1480 times.
✓ Branch 3 taken 363504 times.
 368342 if (pkt && pkt->size == 0)
710 1480 return 0;
711
712
4/4
✓ Branch 0 taken 363504 times.
✓ Branch 1 taken 3358 times.
✓ Branch 2 taken 60276 times.
✓ Branch 3 taken 303228 times.
 366862 if (pkt && (dp->flags & DECODER_FLAG_TS_UNRELIABLE)) {
713 60276 pkt->pts = AV_NOPTS_VALUE;
714 60276 pkt->dts = AV_NOPTS_VALUE;
715 }
716
717
2/2
✓ Branch 0 taken 363504 times.
✓ Branch 1 taken 3358 times.
 366862 if (pkt) {
718 363504 FrameData *fd = packet_data(pkt);
719
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 363504 times.
 363504 if (!fd)
720 ✗ return AVERROR(ENOMEM);
721 363504 fd->wallclock[LATENCY_PROBE_DEC_PRE] = av_gettime_relative();
722 }
723
724 366862 ret = avcodec_send_packet(dec, pkt);
725
3/6
✓ Branch 0 taken 400 times.
✓ Branch 1 taken 366462 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 400 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 366862 if (ret < 0 && !(ret == AVERROR_EOF && !pkt)) {
726 // In particular, we don't expect AVERROR(EAGAIN), because we read all
727 // decoded frames with avcodec_receive_frame() until done.
728
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
 400 if (ret == AVERROR(EAGAIN)) {
729 ✗ av_log(dp, AV_LOG_FATAL, "A decoder returned an unexpected error code. "
730 "This is a bug, please report it.\n");
731 ✗ return AVERROR_BUG;
732 }
733
1/2
✓ Branch 0 taken 400 times.
✗ Branch 1 not taken.
 400 av_log(dp, AV_LOG_ERROR, "Error submitting %s to decoder: %s\n",
734 400 pkt ? "packet" : "EOF", av_err2str(ret));
735
736
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
 400 if (ret == AVERROR_EOF)
737 ✗ return ret;
738
739 400 dp->dec.decode_errors++;
740
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 400 times.
 400 if (exit_on_error)
741 ✗ return ret;
742 }
743
744 383572 while (1) {
745 FrameData *fd;
746 750434 unsigned outputs_mask = 1;
747 750434 unsigned flags = 0;
748
2/2
✓ Branch 0 taken 8700 times.
✓ Branch 1 taken 741734 times.
 750434 if (!dp->dec.frames_decoded)
749 8700 flags |= AV_CODEC_RECEIVE_FRAME_FLAG_SYNCHRONOUS;
750
751 750434 av_frame_unref(frame);
752
753 750434 update_benchmark(NULL);
754 750434 ret = avcodec_receive_frame_flags(dec, frame, flags);
755 750434 update_benchmark("decode_%s %s", type_desc, dp->parent_name);
756
757
2/2
✓ Branch 0 taken 359954 times.
✓ Branch 1 taken 390480 times.
 750434 if (ret == AVERROR(EAGAIN)) {
758
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 359954 times.
 359954 av_assert0(pkt); // should never happen during flushing
759 366862 return 0;
760
2/2
✓ Branch 0 taken 3358 times.
✓ Branch 1 taken 387122 times.
 390480 } else if (ret == AVERROR_EOF) {
761 3358 return ret;
762
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 387116 times.
 387122 } else if (ret < 0) {
763 6 av_log(dp, AV_LOG_ERROR, "Decoding error: %s\n", av_err2str(ret));
764 6 dp->dec.decode_errors++;
765
766
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (exit_on_error)
767 ✗ return ret;
768
769 6 continue;
770 }
771
772
4/4
✓ Branch 0 taken 387079 times.
✓ Branch 1 taken 37 times.
✓ Branch 2 taken 37 times.
✓ Branch 3 taken 387042 times.
 387116 if (frame->decode_error_flags || (frame->flags & AV_FRAME_FLAG_CORRUPT)) {
773
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
 74 av_log(dp, exit_on_error ? AV_LOG_FATAL : AV_LOG_WARNING,
774 "corrupt decoded frame\n");
775
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
 74 if (exit_on_error)
776 ✗ return AVERROR_INVALIDDATA;
777 }
778
779 387116 fd = frame_data(frame);
780
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 387116 times.
 387116 if (!fd) {
781 ✗ av_frame_unref(frame);
782 ✗ return AVERROR(ENOMEM);
783 }
784 387116 fd->dec.pts = frame->pts;
785 387116 fd->dec.tb = dec->pkt_timebase;
786 387116 fd->dec.frame_num = dec->frame_num - 1;
787 387116 fd->bits_per_raw_sample = dec->bits_per_raw_sample;
788
789 387116 fd->wallclock[LATENCY_PROBE_DEC_POST] = av_gettime_relative();
790
791 387116 frame->time_base = dec->pkt_timebase;
792
793
2/2
✓ Branch 0 taken 260697 times.
✓ Branch 1 taken 126419 times.
 387116 if (dec->codec_type == AVMEDIA_TYPE_AUDIO) {
794 260697 dp->dec.samples_decoded += frame->nb_samples;
795
796 260697 audio_ts_process(dp, frame);
797 } else {
798 126419 ret = video_frame_process(dp, frame, &outputs_mask);
799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 126419 times.
 126419 if (ret < 0) {
800 ✗ av_log(dp, AV_LOG_FATAL,
801 "Error while processing the decoded data\n");
802 ✗ return ret;
803 }
804 }
805
806 387116 dp->dec.frames_decoded++;
807
808
2/2
✓ Branch 0 taken 387116 times.
✓ Branch 1 taken 383566 times.
 770682 for (int i = 0; i < stdc_count_ones(outputs_mask); i++) {
809 387116 AVFrame *to_send = frame;
810 int pos;
811
812
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 387116 times.
 387116 av_assert0(outputs_mask);
813
1/2
✓ Branch 0 taken 387116 times.
✗ Branch 1 not taken.
 387116 pos = stdc_trailing_zeros(outputs_mask);
814 387116 outputs_mask &= ~(1U << pos);
815
816 // this is not the last output and sch_dec_send() consumes the frame
817 // given to it, so make a temporary reference
818
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 387116 times.
 387116 if (outputs_mask) {
819 ✗ to_send = dp->frame_tmp_ref;
820 ✗ ret = av_frame_ref(to_send, frame);
821 ✗ if (ret < 0)
822 ✗ return ret;
823 }
824
825 387116 ret = sch_dec_send(dp->sch, dp->sch_idx, pos, to_send);
826
2/2
✓ Branch 0 taken 3550 times.
✓ Branch 1 taken 383566 times.
 387116 if (ret < 0) {
827 3550 av_frame_unref(to_send);
828
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3550 times.
 3550 return ret == AVERROR_EOF ? AVERROR_EXIT : ret;
829 }
830 }
831 }
832 }
833
834 static int dec_open(DecoderPriv *dp, AVDictionary **dec_opts,
835 const DecoderOpts *o, AVFrame *param_out);
836
837 1 static int dec_standalone_open(DecoderPriv *dp, const AVPacket *pkt)
838 {
839 DecoderOpts o;
840 const FrameData *fd;
841 char name[16];
842
843
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!pkt->opaque_ref)
844 ✗ return AVERROR_BUG;
845 1 fd = (FrameData *)pkt->opaque_ref->data;
846
847
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!fd->par_enc)
848 ✗ return AVERROR_BUG;
849
850 1 memset(&o, 0, sizeof(o));
851
852 1 o.par = fd->par_enc;
853 1 o.time_base = pkt->time_base;
854
855 1 o.codec = dp->standalone_init.codec;
856
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (!o.codec)
857 1 o.codec = avcodec_find_decoder(o.par->codec_id);
858
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!o.codec) {
859 ✗ const AVCodecDescriptor *desc = avcodec_descriptor_get(o.par->codec_id);
860
861 ✗ av_log(dp, AV_LOG_ERROR, "Cannot find a decoder for codec ID '%s'\n",
862 desc ? desc->name : "?");
863 ✗ return AVERROR_DECODER_NOT_FOUND;
864 }
865
866 1 snprintf(name, sizeof(name), "dec%d", dp->index);
867 1 o.name = name;
868
869 1 return dec_open(dp, &dp->standalone_init.opts, &o, NULL);
870 }
871
872 6946 static void dec_thread_set_name(const DecoderPriv *dp)
873 {
874 6946 char name[16] = "dec";
875
876
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6945 times.
 6946 if (dp->index >= 0)
877 1 av_strlcatf(name, sizeof(name), "%d", dp->index);
878
1/2
✓ Branch 0 taken 6945 times.
✗ Branch 1 not taken.
 6945 else if (dp->parent_name)
879 6945 av_strlcat(name, dp->parent_name, sizeof(name));
880
881
2/2
✓ Branch 0 taken 6945 times.
✓ Branch 1 taken 1 times.
 6946 if (dp->dec_ctx)
882 6945 av_strlcatf(name, sizeof(name), ":%s", dp->dec_ctx->codec->name);
883
884 6946 ff_thread_setname(name);
885 6946 }
886
887 6946 static void dec_thread_uninit(DecThreadContext *dt)
888 {
889 6946 av_packet_free(&dt->pkt);
890 6946 av_frame_free(&dt->frame);
891
892 6946 memset(dt, 0, sizeof(*dt));
893 6946 }
894
895 6946 static int dec_thread_init(DecThreadContext *dt)
896 {
897 6946 memset(dt, 0, sizeof(*dt));
898
899 6946 dt->frame = av_frame_alloc();
900
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (!dt->frame)
901 ✗ goto fail;
902
903 6946 dt->pkt = av_packet_alloc();
904
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (!dt->pkt)
905 ✗ goto fail;
906
907 6946 return 0;
908
909 ✗ fail:
910 ✗ dec_thread_uninit(dt);
911 ✗ return AVERROR(ENOMEM);
912 }
913
914 6946 static int decoder_thread(void *arg)
915 {
916 6946 DecoderPriv *dp = arg;
917 DecThreadContext dt;
918 6946 int ret = 0, input_status = 0;
919
920 6946 ret = dec_thread_init(&dt);
921
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (ret < 0)
922 ✗ goto finish;
923
924 6946 dec_thread_set_name(dp);
925
926
1/2
✓ Branch 0 taken 371160 times.
✗ Branch 1 not taken.
 371160 while (!input_status) {
927 int flush_buffers, have_data;
928
929 371160 input_status = sch_dec_receive(dp->sch, dp->sch_idx, dt.pkt);
930
2/2
✓ Branch 0 taken 367764 times.
✓ Branch 1 taken 3396 times.
 738924 have_data = input_status >= 0 &&
931
3/4
✓ Branch 0 taken 958 times.
✓ Branch 1 taken 366806 times.
✓ Branch 2 taken 958 times.
✗ Branch 3 not taken.
 367764 (dt.pkt->buf || dt.pkt->side_data_elems ||
932
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 948 times.
 958 (intptr_t)dt.pkt->opaque == PKT_OPAQUE_SUB_HEARTBEAT ||
933
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 6 times.
 10 (intptr_t)dt.pkt->opaque == PKT_OPAQUE_FIX_SUB_DURATION);
934
4/4
✓ Branch 0 taken 367764 times.
✓ Branch 1 taken 3396 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 367758 times.
 371160 flush_buffers = input_status >= 0 && !have_data;
935
2/2
✓ Branch 0 taken 3402 times.
✓ Branch 1 taken 367758 times.
 371160 if (!have_data)
936
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3396 times.
 3402 av_log(dp, AV_LOG_VERBOSE, "Decoder thread received %s packet\n",
937 flush_buffers ? "flush" : "EOF");
938
939 // this is a standalone decoder that has not been initialized yet
940
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 371159 times.
 371160 if (!dp->dec_ctx) {
941
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (flush_buffers)
942 ✗ continue;
943
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (input_status < 0) {
944 ✗ av_log(dp, AV_LOG_ERROR,
945 "Cannot initialize a standalone decoder\n");
946 ✗ ret = input_status;
947 ✗ goto finish;
948 }
949
950 1 ret = dec_standalone_open(dp, dt.pkt);
951
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
952 ✗ goto finish;
953 }
954
955
2/2
✓ Branch 0 taken 367758 times.
✓ Branch 1 taken 3402 times.
 371160 ret = packet_decode(dp, have_data ? dt.pkt : NULL, dt.frame);
956
957 371160 av_packet_unref(dt.pkt);
958 371160 av_frame_unref(dt.frame);
959
960 // AVERROR_EOF - EOF from the decoder
961 // AVERROR_EXIT - EOF from the scheduler
962 // we treat them differently when flushing
963
2/2
✓ Branch 0 taken 3550 times.
✓ Branch 1 taken 367610 times.
 371160 if (ret == AVERROR_EXIT) {
964 3550 ret = AVERROR_EOF;
965 3550 flush_buffers = 0;
966 }
967
968
2/2
✓ Branch 0 taken 6952 times.
✓ Branch 1 taken 364208 times.
 371160 if (ret == AVERROR_EOF) {
969
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6946 times.
 6952 av_log(dp, AV_LOG_VERBOSE, "Decoder returned EOF, %s\n",
970 flush_buffers ? "resetting" : "finishing");
971
972
2/2
✓ Branch 0 taken 6946 times.
✓ Branch 1 taken 6 times.
 6952 if (!flush_buffers)
973 6946 break;
974
975 /* report last frame duration to the scheduler */
976
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3 times.
 6 if (dp->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
977 3 dt.pkt->pts = dp->last_frame_pts + dp->last_frame_duration_est;
978 3 dt.pkt->time_base = dp->last_frame_tb;
979 }
980
981 6 avcodec_flush_buffers(dp->dec_ctx);
982
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 364208 times.
 364208 } else if (ret < 0) {
983 ✗ av_log(dp, AV_LOG_ERROR, "Error processing packet in decoder: %s\n",
984 ✗ av_err2str(ret));
985 ✗ break;
986 }
987 }
988
989 // EOF is normal thread termination
990
1/2
✓ Branch 0 taken 6946 times.
✗ Branch 1 not taken.
 6946 if (ret == AVERROR_EOF)
991 6946 ret = 0;
992
993 // on success send EOF timestamp to our downstreams
994
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (ret >= 0) {
995 float err_rate;
996
997 6946 av_frame_unref(dt.frame);
998
999 6946 dt.frame->opaque = (void*)(intptr_t)FRAME_OPAQUE_EOF;
1000
2/2
✓ Branch 0 taken 6899 times.
✓ Branch 1 taken 47 times.
 6946 dt.frame->pts = dp->last_frame_pts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
1001 6899 dp->last_frame_pts + dp->last_frame_duration_est;
1002 6946 dt.frame->time_base = dp->last_frame_tb;
1003
1004 6946 ret = sch_dec_send(dp->sch, dp->sch_idx, 0, dt.frame);
1005
3/4
✓ Branch 0 taken 3559 times.
✓ Branch 1 taken 3387 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3559 times.
 6946 if (ret < 0 && ret != AVERROR_EOF) {
1006 ✗ av_log(dp, AV_LOG_FATAL,
1007 ✗ "Error signalling EOF timestamp: %s\n", av_err2str(ret));
1008 ✗ goto finish;
1009 }
1010 6946 ret = 0;
1011
1012
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 err_rate = (dp->dec.frames_decoded || dp->dec.decode_errors) ?
1013
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6943 times.
 6949 (float)dp->dec.decode_errors / (dp->dec.frames_decoded + dp->dec.decode_errors) : 0.f;
1014
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 6945 times.
 6946 if (err_rate > max_error_rate) {
1015 1 av_log(dp, AV_LOG_FATAL, "Decode error rate %g exceeds maximum %g\n",
1016 err_rate, max_error_rate);
1017 1 ret = FFMPEG_ERROR_RATE_EXCEEDED;
1018
2/2
✓ Branch 0 taken 6879 times.
✓ Branch 1 taken 66 times.
 6945 } else if (err_rate)
1019 66 av_log(dp, AV_LOG_VERBOSE, "Decode error rate %g\n", err_rate);
1020 }
1021
1022 6879 finish:
1023 6946 dec_thread_uninit(&dt);
1024 6946 avcodec_free_context(&dp->dec_ctx);
1025
1026 6946 return ret;
1027 }
1028
1029 5690 int dec_request_view(Decoder *d, const ViewSpecifier *vs,
1030 SchedulerNode *src)
1031 {
1032 5690 DecoderPriv *dp = dp_from_dec(d);
1033 5690 unsigned out_idx = 0;
1034 int ret;
1035
1036
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5690 times.
 5690 if (dp->multiview_user_config) {
1037 ✗ if (!vs || vs->type == VIEW_SPECIFIER_TYPE_NONE) {
1038 ✗ *src = SCH_DEC_OUT(dp->sch_idx, 0);
1039 ✗ return 0;
1040 }
1041
1042 ✗ av_log(dp, AV_LOG_ERROR,
1043 "Manually selecting views with -view_ids cannot be combined "
1044 "with view selection via stream specifiers. It is strongly "
1045 "recommended you always use stream specifiers only.\n");
1046 ✗ return AVERROR(EINVAL);
1047 }
1048
1049 // when multiview_user_config is not set, NONE specifier is treated
1050 // as requesting the base view
1051
4/4
✓ Branch 0 taken 80 times.
✓ Branch 1 taken 5610 times.
✓ Branch 2 taken 66 times.
✓ Branch 3 taken 14 times.
 5690 vs = (vs && vs->type != VIEW_SPECIFIER_TYPE_NONE) ? vs :
1052 5676 &(ViewSpecifier){ .type = VIEW_SPECIFIER_TYPE_IDX, .val = 0 };
1053
1054 // check if the specifier matches an already-existing one
1055
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 5686 times.
 5696 for (int i = 0; i < dp->nb_views_requested; i++) {
1056 10 const ViewSpecifier *vs1 = &dp->views_requested[i].vs;
1057
1058
1/2
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
 10 if (vs->type == vs1->type &&
1059
3/4
✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 6 times.
 10 (vs->type == VIEW_SPECIFIER_TYPE_ALL || vs->val == vs1->val)) {
1060 4 *src = SCH_DEC_OUT(dp->sch_idx, dp->views_requested[i].out_idx);
1061 4 return 0;
1062 }
1063 }
1064
1065 // we use a bitmask to map view IDs to decoder outputs, which
1066 // limits the number of outputs allowed
1067
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5686 times.
 5686 if (dp->nb_views_requested >= sizeof(dp->view_map[0].out_mask) * 8) {
1068 ✗ av_log(dp, AV_LOG_ERROR, "Too many view specifiers\n");
1069 ✗ return AVERROR(ENOSYS);
1070 }
1071
1072 5686 ret = GROW_ARRAY(dp->views_requested, dp->nb_views_requested);
1073
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5686 times.
 5686 if (ret < 0)
1074 ✗ return ret;
1075
1076
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 5680 times.
 5686 if (dp->nb_views_requested > 1) {
1077 6 ret = sch_add_dec_output(dp->sch, dp->sch_idx);
1078
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (ret < 0)
1079 ✗ return ret;
1080 6 out_idx = ret;
1081 }
1082
1083 5686 dp->views_requested[dp->nb_views_requested - 1].out_idx = out_idx;
1084 5686 dp->views_requested[dp->nb_views_requested - 1].vs = *vs;
1085
1086 5686 *src = SCH_DEC_OUT(dp->sch_idx,
1087 dp->views_requested[dp->nb_views_requested - 1].out_idx);
1088
1089 5686 return 0;
1090 }
1091
1092 1038 static int multiview_setup(DecoderPriv *dp, AVCodecContext *dec_ctx)
1093 {
1094 1038 unsigned views_wanted = 0;
1095
1096 unsigned nb_view_ids_av, nb_view_ids;
1097 1038 unsigned *view_ids_av = NULL, *view_pos_av = NULL;
1098 1038 int *view_ids = NULL;
1099 int ret;
1100
1101 // no views/only base view were requested - do nothing
1102
1/2
✓ Branch 0 taken 1038 times.
✗ Branch 1 not taken.
 1038 if (!dp->nb_views_requested ||
1103
2/2
✓ Branch 0 taken 1029 times.
✓ Branch 1 taken 9 times.
 1038 (dp->nb_views_requested == 1 &&
1104
2/2
✓ Branch 0 taken 1028 times.
✓ Branch 1 taken 1 times.
 1029 dp->views_requested[0].vs.type == VIEW_SPECIFIER_TYPE_IDX &&
1105
2/2
✓ Branch 0 taken 1027 times.
✓ Branch 1 taken 1 times.
 1028 dp->views_requested[0].vs.val == 0))
1106 1027 return 0;
1107
1108 11 av_freep(&dp->view_map);
1109 11 dp->nb_view_map = 0;
1110
1111 // retrieve views available in current CVS
1112 11 ret = av_opt_get_array_size(dec_ctx, "view_ids_available",
1113 AV_OPT_SEARCH_CHILDREN, &nb_view_ids_av);
1114
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (ret < 0) {
1115 ✗ av_log(dp, AV_LOG_ERROR,
1116 "Multiview decoding requested, but decoder '%s' does not "
1117 ✗ "support it\n", dec_ctx->codec->name);
1118 ✗ return AVERROR(ENOSYS);
1119 }
1120
1121
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 2 times.
 11 if (nb_view_ids_av) {
1122 unsigned nb_view_pos_av;
1123
1124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (nb_view_ids_av >= sizeof(views_wanted) * 8) {
1125 ✗ av_log(dp, AV_LOG_ERROR, "Too many views in video: %u\n", nb_view_ids_av);
1126 ✗ ret = AVERROR(ENOSYS);
1127 ✗ goto fail;
1128 }
1129
1130 9 view_ids_av = av_calloc(nb_view_ids_av, sizeof(*view_ids_av));
1131
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (!view_ids_av) {
1132 ✗ ret = AVERROR(ENOMEM);
1133 ✗ goto fail;
1134 }
1135
1136 9 ret = av_opt_get_array(dec_ctx, "view_ids_available",
1137 AV_OPT_SEARCH_CHILDREN, 0, nb_view_ids_av,
1138 AV_OPT_TYPE_UINT, view_ids_av);
1139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
 9 if (ret < 0)
1140 ✗ goto fail;
1141
1142 9 ret = av_opt_get_array_size(dec_ctx, "view_pos_available",
1143 AV_OPT_SEARCH_CHILDREN, &nb_view_pos_av);
1144
3/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 8 times.
 9 if (ret >= 0 && nb_view_pos_av == nb_view_ids_av) {
1145 1 view_pos_av = av_calloc(nb_view_ids_av, sizeof(*view_pos_av));
1146
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!view_pos_av) {
1147 ✗ ret = AVERROR(ENOMEM);
1148 ✗ goto fail;
1149 }
1150
1151 1 ret = av_opt_get_array(dec_ctx, "view_pos_available",
1152 AV_OPT_SEARCH_CHILDREN, 0, nb_view_ids_av,
1153 AV_OPT_TYPE_UINT, view_pos_av);
1154
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
1155 ✗ goto fail;
1156 }
1157 } else {
1158 // assume there is a single view with ID=0
1159 2 nb_view_ids_av = 1;
1160 2 view_ids_av = av_calloc(nb_view_ids_av, sizeof(*view_ids_av));
1161 2 view_pos_av = av_calloc(nb_view_ids_av, sizeof(*view_pos_av));
1162
2/4
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
 2 if (!view_ids_av || !view_pos_av) {
1163 ✗ ret = AVERROR(ENOMEM);
1164 ✗ goto fail;
1165 }
1166 2 view_pos_av[0] = AV_STEREO3D_VIEW_UNSPEC;
1167 }
1168
1169 11 dp->view_map = av_calloc(nb_view_ids_av, sizeof(*dp->view_map));
1170
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!dp->view_map) {
1171 ✗ ret = AVERROR(ENOMEM);
1172 ✗ goto fail;
1173 }
1174 11 dp->nb_view_map = nb_view_ids_av;
1175
1176
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 11 times.
 31 for (int i = 0; i < dp->nb_view_map; i++)
1177 20 dp->view_map[i].id = view_ids_av[i];
1178
1179 // figure out which views should go to which output
1180
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 11 times.
 31 for (int i = 0; i < dp->nb_views_requested; i++) {
1181 20 const ViewSpecifier *vs = &dp->views_requested[i].vs;
1182
1183
4/5
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 20 switch (vs->type) {
1184 9 case VIEW_SPECIFIER_TYPE_IDX:
1185
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 7 times.
 9 if (vs->val >= nb_view_ids_av) {
1186 2 av_log(dp, exit_on_error ? AV_LOG_ERROR : AV_LOG_WARNING,
1187 "View with index %u requested, but only %u views available "
1188 "in current video sequence (more views may or may not be "
1189 "available in later sequences).\n",
1190
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 vs->val, nb_view_ids_av);
1191
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (exit_on_error) {
1192 ✗ ret = AVERROR(EINVAL);
1193 ✗ goto fail;
1194 }
1195
1196 2 continue;
1197 }
1198 7 views_wanted |= 1U << vs->val;
1199 7 dp->view_map[vs->val].out_mask |= 1ULL << i;
1200
1201 7 break;
1202 8 case VIEW_SPECIFIER_TYPE_ID: {
1203 8 int view_idx = -1;
1204
1205
1/2
✓ Branch 0 taken 12 times.
✗ Branch 1 not taken.
 12 for (unsigned j = 0; j < nb_view_ids_av; j++) {
1206
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 4 times.
 12 if (view_ids_av[j] == vs->val) {
1207 8 view_idx = j;
1208 8 break;
1209 }
1210 }
1211
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 if (view_idx < 0) {
1212 ✗ av_log(dp, exit_on_error ? AV_LOG_ERROR : AV_LOG_WARNING,
1213 "View with ID %u requested, but is not available "
1214 ✗ "in the video sequence\n", vs->val);
1215 ✗ if (exit_on_error) {
1216 ✗ ret = AVERROR(EINVAL);
1217 ✗ goto fail;
1218 }
1219
1220 ✗ continue;
1221 }
1222 8 views_wanted |= 1U << view_idx;
1223 8 dp->view_map[view_idx].out_mask |= 1ULL << i;
1224
1225 8 break;
1226 }
1227 2 case VIEW_SPECIFIER_TYPE_POS: {
1228 2 int view_idx = -1;
1229
1230
2/4
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 for (unsigned j = 0; view_pos_av && j < nb_view_ids_av; j++) {
1231
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 if (view_pos_av[j] == vs->val) {
1232 2 view_idx = j;
1233 2 break;
1234 }
1235 }
1236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (view_idx < 0) {
1237 ✗ av_log(dp, exit_on_error ? AV_LOG_ERROR : AV_LOG_WARNING,
1238 "View position '%s' requested, but is not available "
1239 ✗ "in the video sequence\n", av_stereo3d_view_name(vs->val));
1240 ✗ if (exit_on_error) {
1241 ✗ ret = AVERROR(EINVAL);
1242 ✗ goto fail;
1243 }
1244
1245 ✗ continue;
1246 }
1247 2 views_wanted |= 1U << view_idx;
1248 2 dp->view_map[view_idx].out_mask |= 1ULL << i;
1249
1250 2 break;
1251 }
1252 1 case VIEW_SPECIFIER_TYPE_ALL:
1253 1 views_wanted |= (1U << nb_view_ids_av) - 1;
1254
1255
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 for (int j = 0; j < dp->nb_view_map; j++)
1256 2 dp->view_map[j].out_mask |= 1ULL << i;
1257
1258 1 break;
1259 }
1260 }
1261
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!views_wanted) {
1262 ✗ av_log(dp, AV_LOG_ERROR, "No views were selected for decoding\n");
1263 ✗ ret = AVERROR(EINVAL);
1264 ✗ goto fail;
1265 }
1266
1267 // signal to decoder which views we want
1268 11 nb_view_ids = stdc_count_ones(views_wanted);
1269 11 view_ids = av_malloc_array(nb_view_ids, sizeof(*view_ids));
1270
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (!view_ids) {
1271 ✗ ret = AVERROR(ENOMEM);
1272 ✗ goto fail;
1273 }
1274
1275
2/2
✓ Branch 0 taken 19 times.
✓ Branch 1 taken 11 times.
 30 for (unsigned i = 0; i < nb_view_ids; i++) {
1276 int pos;
1277
1278
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19 times.
 19 av_assert0(views_wanted);
1279
1/2
✓ Branch 0 taken 19 times.
✗ Branch 1 not taken.
 19 pos = stdc_trailing_zeros(views_wanted);
1280 19 views_wanted &= ~(1U << pos);
1281
1282 19 view_ids[i] = view_ids_av[pos];
1283 }
1284
1285 // unset view_ids in case we set it earlier
1286 11 av_opt_set(dec_ctx, "view_ids", NULL, AV_OPT_SEARCH_CHILDREN);
1287
1288 11 ret = av_opt_set_array(dec_ctx, "view_ids", AV_OPT_SEARCH_CHILDREN,
1289 0, nb_view_ids, AV_OPT_TYPE_INT, view_ids);
1290
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
 11 if (ret < 0)
1291 ✗ goto fail;
1292
1293
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 8 times.
 11 if (!dp->frame_tmp_ref) {
1294 8 dp->frame_tmp_ref = av_frame_alloc();
1295
1/2
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
 8 if (!dp->frame_tmp_ref) {
1296 ✗ ret = AVERROR(ENOMEM);
1297 ✗ goto fail;
1298 }
1299 }
1300
1301 11 fail:
1302 11 av_freep(&view_ids_av);
1303 11 av_freep(&view_pos_av);
1304 11 av_freep(&view_ids);
1305
1306 11 return ret;
1307 }
1308
1309 6946 static void multiview_check_manual(DecoderPriv *dp, const AVDictionary *dec_opts)
1310 {
1311
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6946 times.
 6946 if (av_dict_get(dec_opts, "view_ids", NULL, 0)) {
1312 ✗ av_log(dp, AV_LOG_WARNING, "Manually selecting views with -view_ids "
1313 "is not recommended, use view specifiers instead\n");
1314 ✗ dp->multiview_user_config = 1;
1315 }
1316 6946 }
1317
1318 1038 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
1319 {
1320 1038 DecoderPriv *dp = s->opaque;
1321 const enum AVPixelFormat *p;
1322 int ret;
1323
1324 1038 ret = multiview_setup(dp, s);
1325
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1038 times.
 1038 if (ret < 0) {
1326 ✗ av_log(dp, AV_LOG_ERROR, "Error setting up multiview decoding: %s\n",
1327 ✗ av_err2str(ret));
1328 ✗ return AV_PIX_FMT_NONE;
1329 }
1330
1331
1/2
✓ Branch 0 taken 2787 times.
✗ Branch 1 not taken.
 2787 for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
1332 2787 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
1333 2787 const AVCodecHWConfig *config = NULL;
1334
1335
2/2
✓ Branch 0 taken 1038 times.
✓ Branch 1 taken 1749 times.
 2787 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1336 1038 break;
1337
1338
1/2
✓ Branch 0 taken 1749 times.
✗ Branch 1 not taken.
 1749 if (dp->hwaccel_id == HWACCEL_GENERIC ||
1339
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1749 times.
 1749 dp->hwaccel_id == HWACCEL_AUTO) {
1340 ✗ for (int i = 0;; i++) {
1341 ✗ config = avcodec_get_hw_config(s->codec, i);
1342 ✗ if (!config)
1343 ✗ break;
1344 ✗ if (!(config->methods &
1345 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
1346 ✗ continue;
1347 ✗ if (config->pix_fmt == *p)
1348 ✗ break;
1349 }
1350 }
1351
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1749 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1749 if (config && config->device_type == dp->hwaccel_device_type) {
1352 ✗ dp->hwaccel_pix_fmt = *p;
1353 ✗ break;
1354 }
1355 }
1356
1357 1038 return *p;
1358 }
1359
1360 360504 static int get_buffer(AVCodecContext *dec_ctx, AVFrame *frame, int flags)
1361 {
1362 360504 DecoderPriv *dp = dec_ctx->opaque;
1363
1364 // for multiview video, store the output mask in frame opaque
1365
2/2
✓ Branch 0 taken 739 times.
✓ Branch 1 taken 359765 times.
 360504 if (dp->nb_view_map) {
1366 739 const AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_VIEW_ID);
1367
2/2
✓ Branch 0 taken 680 times.
✓ Branch 1 taken 59 times.
 739 int view_id = sd ? *(int*)sd->data : 0;
1368
1369
1/2
✓ Branch 0 taken 1079 times.
✗ Branch 1 not taken.
 1079 for (int i = 0; i < dp->nb_view_map; i++) {
1370
2/2
✓ Branch 0 taken 739 times.
✓ Branch 1 taken 340 times.
 1079 if (dp->view_map[i].id == view_id) {
1371 739 frame->opaque = (void*)dp->view_map[i].out_mask;
1372 739 break;
1373 }
1374 }
1375 }
1376
1377 360504 return avcodec_default_get_buffer2(dec_ctx, frame, flags);
1378 }
1379
1380 6946 static HWDevice *hw_device_match_by_codec(const AVCodec *codec)
1381 {
1382 const AVCodecHWConfig *config;
1383 HWDevice *dev;
1384 6946 for (int i = 0;; i++) {
1385 8694 config = avcodec_get_hw_config(codec, i);
1386
2/2
✓ Branch 0 taken 6946 times.
✓ Branch 1 taken 1748 times.
 8694 if (!config)
1387 6946 return NULL;
1388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1748 times.
 1748 if (!(config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
1389 ✗ continue;
1390 1748 dev = hw_device_get_by_type(config->device_type);
1391
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1748 times.
 1748 if (dev)
1392 ✗ return dev;
1393 }
1394 }
1395
1396 6946 static int hw_device_setup_for_decode(DecoderPriv *dp,
1397 const AVCodec *codec,
1398 const char *hwaccel_device)
1399 {
1400 const AVCodecHWConfig *config;
1401 enum AVHWDeviceType type;
1402 6946 HWDevice *dev = NULL;
1403 6946 int err, auto_device = 0;
1404
1405
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (hwaccel_device) {
1406 ✗ dev = hw_device_get_by_name(hwaccel_device);
1407 ✗ if (!dev) {
1408 ✗ if (dp->hwaccel_id == HWACCEL_AUTO) {
1409 ✗ auto_device = 1;
1410 ✗ } else if (dp->hwaccel_id == HWACCEL_GENERIC) {
1411 ✗ type = dp->hwaccel_device_type;
1412 ✗ err = hw_device_init_from_type(type, hwaccel_device,
1413 &dev);
1414 } else {
1415 // This will be dealt with by API-specific initialisation
1416 // (using hwaccel_device), so nothing further needed here.
1417 ✗ return 0;
1418 }
1419 } else {
1420 ✗ if (dp->hwaccel_id == HWACCEL_AUTO) {
1421 ✗ dp->hwaccel_device_type = dev->type;
1422 ✗ } else if (dp->hwaccel_device_type != dev->type) {
1423 ✗ av_log(dp, AV_LOG_ERROR, "Invalid hwaccel device "
1424 "specified for decoder: device %s of type %s is not "
1425 ✗ "usable with hwaccel %s.\n", dev->name,
1426 ✗ av_hwdevice_get_type_name(dev->type),
1427 av_hwdevice_get_type_name(dp->hwaccel_device_type));
1428 ✗ return AVERROR(EINVAL);
1429 }
1430 }
1431 } else {
1432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (dp->hwaccel_id == HWACCEL_AUTO) {
1433 ✗ auto_device = 1;
1434
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 } else if (dp->hwaccel_id == HWACCEL_GENERIC) {
1435 ✗ type = dp->hwaccel_device_type;
1436 ✗ dev = hw_device_get_by_type(type);
1437
1438 // When "-qsv_device device" is used, an internal QSV device named
1439 // as "__qsv_device" is created. Another QSV device is created too
1440 // if "-init_hw_device qsv=name:device" is used. There are 2 QSV devices
1441 // if both "-qsv_device device" and "-init_hw_device qsv=name:device"
1442 // are used, hw_device_get_by_type(AV_HWDEVICE_TYPE_QSV) returns NULL.
1443 // To keep back-compatibility with the removed ad-hoc libmfx setup code,
1444 // call hw_device_get_by_name("__qsv_device") to select the internal QSV
1445 // device.
1446 ✗ if (!dev && type == AV_HWDEVICE_TYPE_QSV)
1447 ✗ dev = hw_device_get_by_name("__qsv_device");
1448
1449 ✗ if (!dev)
1450 ✗ err = hw_device_init_from_type(type, NULL, &dev);
1451 } else {
1452 6946 dev = hw_device_match_by_codec(codec);
1453
1/2
✓ Branch 0 taken 6946 times.
✗ Branch 1 not taken.
 6946 if (!dev) {
1454 // No device for this codec, but not using generic hwaccel
1455 // and therefore may well not need one - ignore.
1456 6946 return 0;
1457 }
1458 }
1459 }
1460
1461 ✗ if (auto_device) {
1462 ✗ if (!avcodec_get_hw_config(codec, 0)) {
1463 // Decoder does not support any hardware devices.
1464 ✗ return 0;
1465 }
1466 ✗ for (int i = 0; !dev; i++) {
1467 ✗ config = avcodec_get_hw_config(codec, i);
1468 ✗ if (!config)
1469 ✗ break;
1470 ✗ type = config->device_type;
1471 ✗ dev = hw_device_get_by_type(type);
1472 ✗ if (dev) {
1473 ✗ av_log(dp, AV_LOG_INFO, "Using auto "
1474 "hwaccel type %s with existing device %s.\n",
1475 ✗ av_hwdevice_get_type_name(type), dev->name);
1476 }
1477 }
1478 ✗ for (int i = 0; !dev; i++) {
1479 ✗ config = avcodec_get_hw_config(codec, i);
1480 ✗ if (!config)
1481 ✗ break;
1482 ✗ type = config->device_type;
1483 // Try to make a new device of this type.
1484 ✗ err = hw_device_init_from_type(type, hwaccel_device,
1485 &dev);
1486 ✗ if (err < 0) {
1487 // Can't make a device of this type.
1488 ✗ continue;
1489 }
1490 ✗ if (hwaccel_device) {
1491 ✗ av_log(dp, AV_LOG_INFO, "Using auto "
1492 "hwaccel type %s with new device created "
1493 "from %s.\n", av_hwdevice_get_type_name(type),
1494 hwaccel_device);
1495 } else {
1496 ✗ av_log(dp, AV_LOG_INFO, "Using auto "
1497 "hwaccel type %s with new default device.\n",
1498 av_hwdevice_get_type_name(type));
1499 }
1500 }
1501 ✗ if (dev) {
1502 ✗ dp->hwaccel_device_type = type;
1503 } else {
1504 ✗ av_log(dp, AV_LOG_INFO, "Auto hwaccel "
1505 "disabled: no device found.\n");
1506 ✗ dp->hwaccel_id = HWACCEL_NONE;
1507 ✗ return 0;
1508 }
1509 }
1510
1511 ✗ if (!dev) {
1512 ✗ av_log(dp, AV_LOG_ERROR, "No device available "
1513 "for decoder: device type %s needed for codec %s.\n",
1514 ✗ av_hwdevice_get_type_name(type), codec->name);
1515 ✗ return err;
1516 }
1517
1518 ✗ dp->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
1519 ✗ if (!dp->dec_ctx->hw_device_ctx)
1520 ✗ return AVERROR(ENOMEM);
1521
1522 ✗ return 0;
1523 }
1524
1525 6946 static int dec_open(DecoderPriv *dp, AVDictionary **dec_opts,
1526 const DecoderOpts *o, AVFrame *param_out)
1527 {
1528 6946 const AVCodec *codec = o->codec;
1529 int ret;
1530
1531 6946 dp->flags = o->flags;
1532 6946 dp->log_parent = o->log_parent;
1533
1534 6946 dp->dec.type = codec->type;
1535 6946 dp->framerate_in = o->framerate;
1536
1537 6946 dp->hwaccel_id = o->hwaccel_id;
1538 6946 dp->hwaccel_device_type = o->hwaccel_device_type;
1539 6946 dp->hwaccel_output_format = o->hwaccel_output_format;
1540
1541 6946 snprintf(dp->log_name, sizeof(dp->log_name), "dec:%s", codec->name);
1542
1543
1/2
✓ Branch 0 taken 6946 times.
✗ Branch 1 not taken.
 6946 dp->parent_name = av_strdup(o->name ? o->name : "");
1544
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (!dp->parent_name)
1545 ✗ return AVERROR(ENOMEM);
1546
1547
2/2
✓ Branch 0 taken 44 times.
✓ Branch 1 taken 6902 times.
 6946 if (codec->type == AVMEDIA_TYPE_SUBTITLE &&
1548
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 42 times.
 44 (dp->flags & DECODER_FLAG_FIX_SUB_DURATION)) {
1549
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
 6 for (int i = 0; i < FF_ARRAY_ELEMS(dp->sub_prev); i++) {
1550 4 dp->sub_prev[i] = av_frame_alloc();
1551
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (!dp->sub_prev[i])
1552 ✗ return AVERROR(ENOMEM);
1553 }
1554 2 dp->sub_heartbeat = av_frame_alloc();
1555
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!dp->sub_heartbeat)
1556 ✗ return AVERROR(ENOMEM);
1557 }
1558
1559 6946 dp->sar_override = o->par->sample_aspect_ratio;
1560
1561 6946 dp->dec_ctx = avcodec_alloc_context3(codec);
1562
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (!dp->dec_ctx)
1563 ✗ return AVERROR(ENOMEM);
1564
1565 6946 ret = avcodec_parameters_to_context(dp->dec_ctx, o->par);
1566
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (ret < 0) {
1567 ✗ av_log(dp, AV_LOG_ERROR, "Error initializing the decoder context.\n");
1568 ✗ return ret;
1569 }
1570
1571 6946 dp->dec_ctx->opaque = dp;
1572 6946 dp->dec_ctx->get_format = get_format;
1573 6946 dp->dec_ctx->get_buffer2 = get_buffer;
1574 6946 dp->dec_ctx->pkt_timebase = o->time_base;
1575
1576
2/2
✓ Branch 1 taken 61 times.
✓ Branch 2 taken 6885 times.
 6946 if (!av_dict_get(*dec_opts, "threads", NULL, 0))
1577 61 av_dict_set(dec_opts, "threads", "auto", 0);
1578
1579 6946 ret = hw_device_setup_for_decode(dp, codec, o->hwaccel_device);
1580
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (ret < 0) {
1581 ✗ av_log(dp, AV_LOG_ERROR,
1582 "Hardware device setup failed for decoder: %s\n",
1583 ✗ av_err2str(ret));
1584 ✗ return ret;
1585 }
1586
1587 6946 ret = av_opt_set_dict2(dp->dec_ctx, dec_opts, AV_OPT_SEARCH_CHILDREN);
1588
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (ret < 0) {
1589 ✗ av_log(dp, AV_LOG_ERROR, "Error applying decoder options: %s\n",
1590 ✗ av_err2str(ret));
1591 ✗ return ret;
1592 }
1593 6946 ret = check_avoptions(*dec_opts);
1594
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (ret < 0)
1595 ✗ return ret;
1596
1597 6946 dp->dec_ctx->flags |= AV_CODEC_FLAG_COPY_OPAQUE;
1598
2/2
✓ Branch 0 taken 79 times.
✓ Branch 1 taken 6867 times.
 6946 if (o->flags & DECODER_FLAG_BITEXACT)
1599 79 dp->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1600
1601 // we apply cropping ourselves
1602 6946 dp->apply_cropping = dp->dec_ctx->apply_cropping;
1603 6946 dp->dec_ctx->apply_cropping = 0;
1604
1605
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6946 times.
 6946 if ((ret = avcodec_open2(dp->dec_ctx, codec, NULL)) < 0) {
1606 ✗ av_log(dp, AV_LOG_ERROR, "Error while opening decoder: %s\n",
1607 ✗ av_err2str(ret));
1608 ✗ return ret;
1609 }
1610
1611
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6946 times.
 6946 if (dp->dec_ctx->hw_device_ctx) {
1612 // Update decoder extra_hw_frames option to account for the
1613 // frames held in queues inside the ffmpeg utility. This is
1614 // called after avcodec_open2() because the user-set value of
1615 // extra_hw_frames becomes valid in there, and we need to add
1616 // this on top of it.
1617 ✗ int extra_frames = DEFAULT_FRAME_THREAD_QUEUE_SIZE;
1618 ✗ if (dp->dec_ctx->extra_hw_frames >= 0)
1619 ✗ dp->dec_ctx->extra_hw_frames += extra_frames;
1620 else
1621 ✗ dp->dec_ctx->extra_hw_frames = extra_frames;
1622 }
1623
1624 6946 dp->dec.subtitle_header = dp->dec_ctx->subtitle_header;
1625 6946 dp->dec.subtitle_header_size = dp->dec_ctx->subtitle_header_size;
1626
1627
2/2
✓ Branch 0 taken 6945 times.
✓ Branch 1 taken 1 times.
 6946 if (param_out) {
1628
2/2
✓ Branch 0 taken 1222 times.
✓ Branch 1 taken 5723 times.
 6945 if (dp->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1629 1222 param_out->format = dp->dec_ctx->sample_fmt;
1630 1222 param_out->sample_rate = dp->dec_ctx->sample_rate;
1631
1632 1222 ret = av_channel_layout_copy(&param_out->ch_layout, &dp->dec_ctx->ch_layout);
1633
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1222 times.
 1222 if (ret < 0)
1634 ✗ return ret;
1635
2/2
✓ Branch 0 taken 5679 times.
✓ Branch 1 taken 44 times.
 5723 } else if (dp->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1636 5679 param_out->format = dp->dec_ctx->pix_fmt;
1637 5679 param_out->width = dp->dec_ctx->width;
1638 5679 param_out->height = dp->dec_ctx->height;
1639 5679 param_out->sample_aspect_ratio = dp->dec_ctx->sample_aspect_ratio;
1640 5679 param_out->colorspace = dp->dec_ctx->colorspace;
1641 5679 param_out->color_range = dp->dec_ctx->color_range;
1642 5679 param_out->alpha_mode = dp->dec_ctx->alpha_mode;
1643 }
1644
1645 6945 av_frame_side_data_free(&param_out->side_data, &param_out->nb_side_data);
1646 6945 ret = clone_side_data(&param_out->side_data, &param_out->nb_side_data,
1647 6945 dp->dec_ctx->decoded_side_data, dp->dec_ctx->nb_decoded_side_data, 0);
1648
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6945 times.
 6945 if (ret < 0)
1649 ✗ return ret;
1650 6945 param_out->time_base = dp->dec_ctx->pkt_timebase;
1651 }
1652
1653 6946 return 0;
1654 }
1655
1656 6945 int dec_init(Decoder **pdec, Scheduler *sch,
1657 AVDictionary **dec_opts, const DecoderOpts *o,
1658 AVFrame *param_out)
1659 {
1660 DecoderPriv *dp;
1661 int ret;
1662
1663 6945 *pdec = NULL;
1664
1665 6945 ret = dec_alloc(&dp, sch, !!(o->flags & DECODER_FLAG_SEND_END_TS));
1666
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6945 times.
 6945 if (ret < 0)
1667 ✗ return ret;
1668
1669 6945 multiview_check_manual(dp, *dec_opts);
1670
1671 6945 ret = dec_open(dp, dec_opts, o, param_out);
1672
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6945 times.
 6945 if (ret < 0)
1673 ✗ goto fail;
1674
1675 6945 *pdec = &dp->dec;
1676
1677 6945 return dp->sch_idx;
1678 ✗ fail:
1679 ✗ dec_free((Decoder**)&dp);
1680 ✗ return ret;
1681 }
1682
1683 1 int dec_create(const OptionsContext *o, const char *arg, Scheduler *sch)
1684 {
1685 DecoderPriv *dp;
1686
1687 OutputFile *of;
1688 OutputStream *ost;
1689 int of_index, ost_index;
1690 char *p;
1691
1692 unsigned enc_idx;
1693 int ret;
1694
1695 1 ret = dec_alloc(&dp, sch, 0);
1696
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
1697 ✗ return ret;
1698
1699 1 dp->index = nb_decoders;
1700
1701 1 ret = GROW_ARRAY(decoders, nb_decoders);
1702
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0) {
1703 ✗ dec_free((Decoder **)&dp);
1704 ✗ return ret;
1705 }
1706
1707 1 decoders[nb_decoders - 1] = (Decoder *)dp;
1708
1709 1 of_index = strtol(arg, &p, 0);
1710
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (of_index < 0 || of_index >= nb_output_files) {
1711 ✗ av_log(dp, AV_LOG_ERROR, "Invalid output file index '%d' in %s\n", of_index, arg);
1712 ✗ return AVERROR(EINVAL);
1713 }
1714 1 of = output_files[of_index];
1715
1716 1 ost_index = strtol(p + 1, NULL, 0);
1717
2/4
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
 1 if (ost_index < 0 || ost_index >= of->nb_streams) {
1718 ✗ av_log(dp, AV_LOG_ERROR, "Invalid output stream index '%d' in %s\n", ost_index, arg);
1719 ✗ return AVERROR(EINVAL);
1720 }
1721 1 ost = of->streams[ost_index];
1722
1723
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!ost->enc) {
1724 ✗ av_log(dp, AV_LOG_ERROR, "Output stream %s has no encoder\n", arg);
1725 ✗ return AVERROR(EINVAL);
1726 }
1727
1728 1 dp->dec.type = ost->type;
1729
1730 1 ret = enc_loopback(ost->enc);
1731
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
1732 ✗ return ret;
1733 1 enc_idx = ret;
1734
1735 1 ret = sch_connect(sch, SCH_ENC(enc_idx), SCH_DEC_IN(dp->sch_idx));
1736
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
1737 ✗ return ret;
1738
1739 1 ret = av_dict_copy(&dp->standalone_init.opts, o->g->codec_opts, 0);
1740
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (ret < 0)
1741 ✗ return ret;
1742
1743 1 multiview_check_manual(dp, dp->standalone_init.opts);
1744
1745
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (o->codec_names.nb_opt) {
1746 ✗ const char *name = o->codec_names.opt[o->codec_names.nb_opt - 1].u.str;
1747 ✗ dp->standalone_init.codec = avcodec_find_decoder_by_name(name);
1748 ✗ if (!dp->standalone_init.codec) {
1749 ✗ av_log(dp, AV_LOG_ERROR, "No such decoder: %s\n", name);
1750 ✗ return AVERROR_DECODER_NOT_FOUND;
1751 }
1752 }
1753
1754 1 return 0;
1755 }
1756
1757 1 int dec_filter_add(Decoder *d, InputFilter *ifilter, InputFilterOptions *opts,
1758 const ViewSpecifier *vs, SchedulerNode *src)
1759 {
1760 1 DecoderPriv *dp = dp_from_dec(d);
1761 char name[16];
1762
1763 1 snprintf(name, sizeof(name), "dec%d", dp->index);
1764 1 opts->name = av_strdup(name);
1765
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!opts->name)
1766 ✗ return AVERROR(ENOMEM);
1767
1768 1 return dec_request_view(d, vs, src);
1769 }
1770