FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/decode.c
Date: 2024-09-13 17:16:59
Exec Total Coverage
Lines: 755 1157 65.3%
Functions: 59 62 95.2%
Branches: 479 847 56.6%
Line Branch Exec Source
1 /*
2 * generic decoding-related code
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include <stdint.h>
22 #include <string.h>
23
24 #include "config.h"
25
26 #if CONFIG_ICONV
27 # include <iconv.h>
28 #endif
29
30 #include "libavutil/avassert.h"
31 #include "libavutil/channel_layout.h"
32 #include "libavutil/common.h"
33 #include "libavutil/emms.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/hwcontext.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/mastering_display_metadata.h"
39 #include "libavutil/mem.h"
40
41 #include "avcodec.h"
42 #include "avcodec_internal.h"
43 #include "bytestream.h"
44 #include "bsf.h"
45 #include "codec_desc.h"
46 #include "codec_internal.h"
47 #include "decode.h"
48 #include "hwaccel_internal.h"
49 #include "hwconfig.h"
50 #include "internal.h"
51 #include "packet_internal.h"
52 #include "progressframe.h"
53 #include "refstruct.h"
54 #include "thread.h"
55 #include "threadprogress.h"
56
57 typedef struct DecodeContext {
58 AVCodecInternal avci;
59
60 /**
61 * This is set to AV_FRAME_FLAG_KEY for decoders of intra-only formats
62 * (those whose codec descriptor has AV_CODEC_PROP_INTRA_ONLY set)
63 * to set the flag generically.
64 */
65 int intra_only_flag;
66
67 /**
68 * This is set to AV_PICTURE_TYPE_I for intra only video decoders
69 * and to AV_PICTURE_TYPE_NONE for other decoders. It is used to set
70 * the AVFrame's pict_type before the decoder receives it.
71 */
72 enum AVPictureType initial_pict_type;
73
74 /* to prevent infinite loop on errors when draining */
75 int nb_draining_errors;
76
77 /**
78 * The caller has submitted a NULL packet on input.
79 */
80 int draining_started;
81
82 int64_t pts_correction_num_faulty_pts; /// Number of incorrect PTS values so far
83 int64_t pts_correction_num_faulty_dts; /// Number of incorrect DTS values so far
84 int64_t pts_correction_last_pts; /// PTS of the last frame
85 int64_t pts_correction_last_dts; /// DTS of the last frame
86
87 /**
88 * Bitmask indicating for which side data types we prefer user-supplied
89 * (global or attached to packets) side data over bytestream.
90 */
91 uint64_t side_data_pref_mask;
92 } DecodeContext;
93
94 3495503 static DecodeContext *decode_ctx(AVCodecInternal *avci)
95 {
96 3495503 return (DecodeContext *)avci;
97 }
98
99 380773 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
100 {
101 int ret;
102 size_t size;
103 const uint8_t *data;
104 uint32_t flags;
105 int64_t val;
106
107 380773 data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
108
2/2
✓ Branch 0 taken 380771 times.
✓ Branch 1 taken 2 times.
 380773 if (!data)
109 380771 return 0;
110
111
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
112 ✗ av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
113 "changes, but PARAM_CHANGE side data was sent to it.\n");
114 ✗ ret = AVERROR(EINVAL);
115 ✗ goto fail2;
116 }
117
118
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (size < 4)
119 ✗ goto fail;
120
121 2 flags = bytestream_get_le32(&data);
122 2 size -= 4;
123
124
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
125 ✗ if (size < 4)
126 ✗ goto fail;
127 ✗ val = bytestream_get_le32(&data);
128 ✗ if (val <= 0 || val > INT_MAX) {
129 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
130 ✗ ret = AVERROR_INVALIDDATA;
131 ✗ goto fail2;
132 }
133 ✗ avctx->sample_rate = val;
134 ✗ size -= 4;
135 }
136
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
137
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (size < 8)
138 ✗ goto fail;
139 2 avctx->width = bytestream_get_le32(&data);
140 2 avctx->height = bytestream_get_le32(&data);
141 2 size -= 8;
142 2 ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
143
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (ret < 0)
144 ✗ goto fail2;
145 }
146
147 2 return 0;
148 ✗ fail:
149 ✗ av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
150 ✗ ret = AVERROR_INVALIDDATA;
151 ✗ fail2:
152 ✗ if (ret < 0) {
153 ✗ av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
154 ✗ if (avctx->err_recognition & AV_EF_EXPLODE)
155 ✗ return ret;
156 }
157 ✗ return 0;
158 }
159
160 380773 static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
161 {
162 380773 int ret = 0;
163
164 380773 av_packet_unref(avci->last_pkt_props);
165
1/2
✓ Branch 0 taken 380773 times.
✗ Branch 1 not taken.
 380773 if (pkt) {
166 380773 ret = av_packet_copy_props(avci->last_pkt_props, pkt);
167 #if FF_API_FRAME_PKT
168
1/2
✓ Branch 0 taken 380773 times.
✗ Branch 1 not taken.
 380773 if (!ret)
169 380773 avci->last_pkt_props->stream_index = pkt->size; // Needed for ff_decode_frame_props().
170 #endif
171 }
172 380773 return ret;
173 }
174
175 14608 static int decode_bsfs_init(AVCodecContext *avctx)
176 {
177 14608 AVCodecInternal *avci = avctx->internal;
178 14608 const FFCodec *const codec = ffcodec(avctx->codec);
179 int ret;
180
181
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if (avci->bsf)
182 ✗ return 0;
183
184 14608 ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf);
185
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if (ret < 0) {
186 ✗ av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret));
187 ✗ if (ret != AVERROR(ENOMEM))
188 ✗ ret = AVERROR_BUG;
189 ✗ goto fail;
190 }
191
192 /* We do not currently have an API for passing the input timebase into decoders,
193 * but no filters used here should actually need it.
194 * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
195 14608 avci->bsf->time_base_in = (AVRational){ 1, 90000 };
196 14608 ret = avcodec_parameters_from_context(avci->bsf->par_in, avctx);
197
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if (ret < 0)
198 ✗ goto fail;
199
200 14608 ret = av_bsf_init(avci->bsf);
201
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if (ret < 0)
202 ✗ goto fail;
203
204 14608 return 0;
205 ✗ fail:
206 ✗ av_bsf_free(&avci->bsf);
207 ✗ return ret;
208 }
209
210 #if !HAVE_THREADS
211 #define ff_thread_get_packet(avctx, pkt) (AVERROR_BUG)
212 #define ff_thread_receive_frame(avctx, frame) (AVERROR_BUG)
213 #endif
214
215 1144386 static int decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
216 {
217 1144386 AVCodecInternal *avci = avctx->internal;
218 int ret;
219
220 1144386 ret = av_bsf_receive_packet(avci->bsf, pkt);
221
2/2
✓ Branch 0 taken 763613 times.
✓ Branch 1 taken 380773 times.
 1144386 if (ret < 0)
222 763613 return ret;
223
224
1/2
✓ Branch 1 taken 380773 times.
✗ Branch 2 not taken.
 380773 if (!(ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) {
225 380773 ret = extract_packet_props(avctx->internal, pkt);
226
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380773 times.
 380773 if (ret < 0)
227 ✗ goto finish;
228 }
229
230 380773 ret = apply_param_change(avctx, pkt);
231
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380773 times.
 380773 if (ret < 0)
232 ✗ goto finish;
233
234 380773 return 0;
235 ✗ finish:
236 ✗ av_packet_unref(pkt);
237 ✗ return ret;
238 }
239
240 761577 int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
241 {
242 761577 AVCodecInternal *avci = avctx->internal;
243 761577 DecodeContext *dc = decode_ctx(avci);
244
245
2/2
✓ Branch 0 taken 187 times.
✓ Branch 1 taken 761390 times.
 761577 if (avci->draining)
246 187 return AVERROR_EOF;
247
248 /* If we are a worker thread, get the next packet from the threading
249 * context. Otherwise we are the main (user-facing) context, so we get the
250 * next packet from the input filterchain.
251 */
252
2/2
✓ Branch 0 taken 760314 times.
✓ Branch 1 taken 1076 times.
 761390 if (avctx->internal->is_frame_mt)
253 1076 return ff_thread_get_packet(avctx, pkt);
254
255 384072 while (1) {
256 1144386 int ret = decode_get_packet(avctx, pkt);
257
2/2
✓ Branch 0 taken 760250 times.
✓ Branch 1 taken 384136 times.
 1144386 if (ret == AVERROR(EAGAIN) &&
258
5/6
✓ Branch 0 taken 379541 times.
✓ Branch 1 taken 380709 times.
✓ Branch 2 taken 379541 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3363 times.
✓ Branch 5 taken 376178 times.
 760250 (!AVPACKET_IS_EMPTY(avci->buffer_pkt) || dc->draining_started)) {
259 384072 ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
260
1/2
✓ Branch 0 taken 384072 times.
✗ Branch 1 not taken.
 384072 if (ret >= 0)
261 384072 continue;
262
263 ✗ av_packet_unref(avci->buffer_pkt);
264 }
265
266
2/2
✓ Branch 0 taken 3363 times.
✓ Branch 1 taken 756951 times.
 760314 if (ret == AVERROR_EOF)
267 3363 avci->draining = 1;
268 760314 return ret;
269 }
270 }
271
272 /**
273 * Attempt to guess proper monotonic timestamps for decoded video frames
274 * which might have incorrect times. Input timestamps may wrap around, in
275 * which case the output will as well.
276 *
277 * @param pts the pts field of the decoded AVPacket, as passed through
278 * AVFrame.pts
279 * @param dts the dts field of the decoded AVPacket
280 * @return one of the input values, may be AV_NOPTS_VALUE
281 */
282 399069 static int64_t guess_correct_pts(DecodeContext *dc,
283 int64_t reordered_pts, int64_t dts)
284 {
285 399069 int64_t pts = AV_NOPTS_VALUE;
286
287
2/2
✓ Branch 0 taken 309702 times.
✓ Branch 1 taken 89367 times.
 399069 if (dts != AV_NOPTS_VALUE) {
288 309702 dc->pts_correction_num_faulty_dts += dts <= dc->pts_correction_last_dts;
289 309702 dc->pts_correction_last_dts = dts;
290
2/2
✓ Branch 0 taken 353 times.
✓ Branch 1 taken 89014 times.
 89367 } else if (reordered_pts != AV_NOPTS_VALUE)
291 353 dc->pts_correction_last_dts = reordered_pts;
292
293
2/2
✓ Branch 0 taken 309360 times.
✓ Branch 1 taken 89709 times.
 399069 if (reordered_pts != AV_NOPTS_VALUE) {
294 309360 dc->pts_correction_num_faulty_pts += reordered_pts <= dc->pts_correction_last_pts;
295 309360 dc->pts_correction_last_pts = reordered_pts;
296
2/2
✓ Branch 0 taken 695 times.
✓ Branch 1 taken 89014 times.
 89709 } else if(dts != AV_NOPTS_VALUE)
297 695 dc->pts_correction_last_pts = dts;
298
299
4/4
✓ Branch 0 taken 566 times.
✓ Branch 1 taken 398503 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 557 times.
 399069 if ((dc->pts_correction_num_faulty_pts<=dc->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
300
2/2
✓ Branch 0 taken 308803 times.
✓ Branch 1 taken 89709 times.
 398512 && reordered_pts != AV_NOPTS_VALUE)
301 308803 pts = reordered_pts;
302 else
303 90266 pts = dts;
304
305 399069 return pts;
306 }
307
308 261393 static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
309 {
310 261393 AVCodecInternal *avci = avctx->internal;
311 AVFrameSideData *side;
312 261393 uint32_t discard_padding = 0;
313 261393 uint8_t skip_reason = 0;
314 261393 uint8_t discard_reason = 0;
315
316 261393 side = av_frame_get_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES);
317
3/4
✓ Branch 0 taken 116 times.
✓ Branch 1 taken 261277 times.
✓ Branch 2 taken 116 times.
✗ Branch 3 not taken.
 261393 if (side && side->size >= 10) {
318 116 avci->skip_samples = AV_RL32(side->data);
319 116 avci->skip_samples = FFMAX(0, avci->skip_samples);
320 116 discard_padding = AV_RL32(side->data + 4);
321 116 av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
322 avci->skip_samples, (int)discard_padding);
323 116 skip_reason = AV_RL8(side->data + 8);
324 116 discard_reason = AV_RL8(side->data + 9);
325 }
326
327
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 261393 times.
 261393 if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
328 ✗ if (!side && (avci->skip_samples || discard_padding))
329 ✗ side = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10);
330 ✗ if (side && (avci->skip_samples || discard_padding)) {
331 ✗ AV_WL32(side->data, avci->skip_samples);
332 ✗ AV_WL32(side->data + 4, discard_padding);
333 ✗ AV_WL8(side->data + 8, skip_reason);
334 ✗ AV_WL8(side->data + 9, discard_reason);
335 ✗ avci->skip_samples = 0;
336 }
337 ✗ return 0;
338 }
339 261393 av_frame_remove_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES);
340
341
2/2
✓ Branch 0 taken 20 times.
✓ Branch 1 taken 261373 times.
 261393 if ((frame->flags & AV_FRAME_FLAG_DISCARD)) {
342 20 avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
343 20 *discarded_samples += frame->nb_samples;
344 20 return AVERROR(EAGAIN);
345 }
346
347
2/2
✓ Branch 0 taken 221 times.
✓ Branch 1 taken 261152 times.
 261373 if (avci->skip_samples > 0) {
348
2/2
✓ Branch 0 taken 156 times.
✓ Branch 1 taken 65 times.
 221 if (frame->nb_samples <= avci->skip_samples){
349 156 *discarded_samples += frame->nb_samples;
350 156 avci->skip_samples -= frame->nb_samples;
351 156 av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
352 avci->skip_samples);
353 156 return AVERROR(EAGAIN);
354 } else {
355 65 av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
356 65 frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format);
357
2/4
✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 65 times.
✗ Branch 3 not taken.
 130 if (avctx->pkt_timebase.num && avctx->sample_rate) {
358 65 int64_t diff_ts = av_rescale_q(avci->skip_samples,
359 65 (AVRational){1, avctx->sample_rate},
360 avctx->pkt_timebase);
361
1/2
✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
 65 if (frame->pts != AV_NOPTS_VALUE)
362 65 frame->pts += diff_ts;
363
1/2
✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
 65 if (frame->pkt_dts != AV_NOPTS_VALUE)
364 65 frame->pkt_dts += diff_ts;
365
1/2
✓ Branch 0 taken 65 times.
✗ Branch 1 not taken.
 65 if (frame->duration >= diff_ts)
366 65 frame->duration -= diff_ts;
367 } else
368 ✗ av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
369
370 65 av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
371 avci->skip_samples, frame->nb_samples);
372 65 *discarded_samples += avci->skip_samples;
373 65 frame->nb_samples -= avci->skip_samples;
374 65 avci->skip_samples = 0;
375 }
376 }
377
378
3/4
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 261210 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
 261217 if (discard_padding > 0 && discard_padding <= frame->nb_samples) {
379
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5 times.
 7 if (discard_padding == frame->nb_samples) {
380 2 *discarded_samples += frame->nb_samples;
381 2 return AVERROR(EAGAIN);
382 } else {
383
2/4
✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 5 if (avctx->pkt_timebase.num && avctx->sample_rate) {
384 5 int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
385 5 (AVRational){1, avctx->sample_rate},
386 avctx->pkt_timebase);
387 5 frame->duration = diff_ts;
388 } else
389 ✗ av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
390
391 5 av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
392 (int)discard_padding, frame->nb_samples);
393 5 frame->nb_samples -= discard_padding;
394 }
395 }
396
397 261215 return 0;
398 }
399
400 /*
401 * The core of the receive_frame_wrapper for the decoders implementing
402 * the simple API. Certain decoders might consume partial packets without
403 * returning any output, so this function needs to be called in a loop until it
404 * returns EAGAIN.
405 **/
406 768741 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
407 {
408 768741 AVCodecInternal *avci = avctx->internal;
409 768741 DecodeContext *dc = decode_ctx(avci);
410 768741 AVPacket *const pkt = avci->in_pkt;
411 768741 const FFCodec *const codec = ffcodec(avctx->codec);
412 int got_frame, consumed;
413 int ret;
414
415
4/4
✓ Branch 0 taken 740122 times.
✓ Branch 1 taken 28619 times.
✓ Branch 2 taken 738874 times.
✓ Branch 3 taken 1248 times.
 768741 if (!pkt->data && !avci->draining) {
416 738874 av_packet_unref(pkt);
417 738874 ret = ff_decode_get_packet(avctx, pkt);
418
4/4
✓ Branch 0 taken 368873 times.
✓ Branch 1 taken 370001 times.
✓ Branch 2 taken 365702 times.
✓ Branch 3 taken 3171 times.
 738874 if (ret < 0 && ret != AVERROR_EOF)
419 365702 return ret;
420 }
421
422 // Some codecs (at least wma lossless) will crash when feeding drain packets
423 // after EOF was signaled.
424
2/2
✓ Branch 0 taken 555 times.
✓ Branch 1 taken 402484 times.
 403039 if (avci->draining_done)
425 555 return AVERROR_EOF;
426
427
2/2
✓ Branch 0 taken 3864 times.
✓ Branch 1 taken 398620 times.
 402484 if (!pkt->data &&
428
2/2
✓ Branch 0 taken 2683 times.
✓ Branch 1 taken 1181 times.
 3864 !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
429 2683 return AVERROR_EOF;
430
431 399801 got_frame = 0;
432
433 399801 frame->pict_type = dc->initial_pict_type;
434 399801 frame->flags |= dc->intra_only_flag;
435 399801 consumed = codec->cb.decode(avctx, frame, &got_frame, pkt);
436
437
1/2
✓ Branch 0 taken 399801 times.
✗ Branch 1 not taken.
 399801 if (!(codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS))
438 399801 frame->pkt_dts = pkt->dts;
439
2/2
✓ Branch 0 taken 138840 times.
✓ Branch 1 taken 260961 times.
 399801 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
440 #if FF_API_FRAME_PKT
441 FF_DISABLE_DEPRECATION_WARNINGS
442
2/2
✓ Branch 0 taken 111006 times.
✓ Branch 1 taken 27834 times.
 138840 if(!avctx->has_b_frames)
443 111006 frame->pkt_pos = pkt->pos;
444 FF_ENABLE_DEPRECATION_WARNINGS
445 #endif
446 }
447 399801 emms_c();
448
449
2/2
✓ Branch 0 taken 138840 times.
✓ Branch 1 taken 260961 times.
 399801 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
450
2/2
✓ Branch 0 taken 178 times.
✓ Branch 1 taken 128449 times.
 267467 ret = (!got_frame || frame->flags & AV_FRAME_FLAG_DISCARD)
451 ? AVERROR(EAGAIN)
452
2/2
✓ Branch 0 taken 128627 times.
✓ Branch 1 taken 10213 times.
 267467 : 0;
453
1/2
✓ Branch 0 taken 260961 times.
✗ Branch 1 not taken.
 260961 } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
454 260961 ret = !got_frame ? AVERROR(EAGAIN)
455
2/2
✓ Branch 0 taken 259584 times.
✓ Branch 1 taken 1377 times.
 260961 : discard_samples(avctx, frame, discarded_samples);
456 } else
457 ✗ av_assert0(0);
458
459
2/2
✓ Branch 0 taken 11946 times.
✓ Branch 1 taken 387855 times.
 399801 if (ret == AVERROR(EAGAIN))
460 11946 av_frame_unref(frame);
461
462 // FF_CODEC_CB_TYPE_DECODE decoders must not return AVERROR EAGAIN
463 // code later will add AVERROR(EAGAIN) to a pointer
464
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 399801 times.
 399801 av_assert0(consumed != AVERROR(EAGAIN));
465
2/2
✓ Branch 0 taken 641 times.
✓ Branch 1 taken 399160 times.
 399801 if (consumed < 0)
466 641 ret = consumed;
467
4/4
✓ Branch 0 taken 399160 times.
✓ Branch 1 taken 641 times.
✓ Branch 2 taken 138236 times.
✓ Branch 3 taken 260924 times.
 399801 if (consumed >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
468 138236 consumed = pkt->size;
469
470
2/2
✓ Branch 0 taken 387855 times.
✓ Branch 1 taken 11946 times.
 399801 if (!ret)
471
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 387855 times.
 387855 av_assert0(frame->buf[0]);
472
2/2
✓ Branch 0 taken 11305 times.
✓ Branch 1 taken 388496 times.
 399801 if (ret == AVERROR(EAGAIN))
473 11305 ret = 0;
474
475 /* do not stop draining when got_frame != 0 or ret < 0 */
476
4/4
✓ Branch 0 taken 1181 times.
✓ Branch 1 taken 398620 times.
✓ Branch 2 taken 556 times.
✓ Branch 3 taken 625 times.
 399801 if (avci->draining && !got_frame) {
477
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 555 times.
 556 if (ret < 0) {
478 /* prevent infinite loop if a decoder wrongly always return error on draining */
479 /* reasonable nb_errors_max = maximum b frames + thread count */
480
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
481 ✗ avctx->thread_count : 1);
482
483
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (decode_ctx(avci)->nb_draining_errors++ >= nb_errors_max) {
484 ✗ av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
485 "Stop draining and force EOF.\n");
486 ✗ avci->draining_done = 1;
487 ✗ ret = AVERROR_BUG;
488 }
489 } else {
490 555 avci->draining_done = 1;
491 }
492 }
493
494
4/4
✓ Branch 0 taken 29274 times.
✓ Branch 1 taken 370527 times.
✓ Branch 2 taken 641 times.
✓ Branch 3 taken 28633 times.
 399801 if (consumed >= pkt->size || ret < 0) {
495 371168 av_packet_unref(pkt);
496 } else {
497 28633 pkt->data += consumed;
498 28633 pkt->size -= consumed;
499 28633 pkt->pts = AV_NOPTS_VALUE;
500 28633 pkt->dts = AV_NOPTS_VALUE;
501
1/2
✓ Branch 0 taken 28633 times.
✗ Branch 1 not taken.
 28633 if (!(codec->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) {
502 #if FF_API_FRAME_PKT
503 // See extract_packet_props() comment.
504 28633 avci->last_pkt_props->stream_index = avci->last_pkt_props->stream_index - consumed;
505 #endif
506 28633 avci->last_pkt_props->pts = AV_NOPTS_VALUE;
507 28633 avci->last_pkt_props->dts = AV_NOPTS_VALUE;
508 }
509 }
510
511 399801 return ret;
512 }
513
514 #if CONFIG_LCMS2
515 static int detect_colorspace(AVCodecContext *avctx, AVFrame *frame)
516 {
517 AVCodecInternal *avci = avctx->internal;
518 enum AVColorTransferCharacteristic trc;
519 AVColorPrimariesDesc coeffs;
520 enum AVColorPrimaries prim;
521 cmsHPROFILE profile;
522 AVFrameSideData *sd;
523 int ret;
524 if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
525 return 0;
526
527 sd = av_frame_get_side_data(frame, AV_FRAME_DATA_ICC_PROFILE);
528 if (!sd || !sd->size)
529 return 0;
530
531 if (!avci->icc.avctx) {
532 ret = ff_icc_context_init(&avci->icc, avctx);
533 if (ret < 0)
534 return ret;
535 }
536
537 profile = cmsOpenProfileFromMemTHR(avci->icc.ctx, sd->data, sd->size);
538 if (!profile)
539 return AVERROR_INVALIDDATA;
540
541 ret = ff_icc_profile_sanitize(&avci->icc, profile);
542 if (!ret)
543 ret = ff_icc_profile_read_primaries(&avci->icc, profile, &coeffs);
544 if (!ret)
545 ret = ff_icc_profile_detect_transfer(&avci->icc, profile, &trc);
546 cmsCloseProfile(profile);
547 if (ret < 0)
548 return ret;
549
550 prim = av_csp_primaries_id_from_desc(&coeffs);
551 if (prim != AVCOL_PRI_UNSPECIFIED)
552 frame->color_primaries = prim;
553 if (trc != AVCOL_TRC_UNSPECIFIED)
554 frame->color_trc = trc;
555 return 0;
556 }
557 #else /* !CONFIG_LCMS2 */
558 780234 static int detect_colorspace(av_unused AVCodecContext *c, av_unused AVFrame *f)
559 {
560 780234 return 0;
561 }
562 #endif
563
564 800509 static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame)
565 {
566 int ret;
567
568
2/2
✓ Branch 0 taken 538494 times.
✓ Branch 1 taken 262015 times.
 800509 if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
569 538494 frame->color_primaries = avctx->color_primaries;
570
2/2
✓ Branch 0 taken 538133 times.
✓ Branch 1 taken 262376 times.
 800509 if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
571 538133 frame->color_trc = avctx->color_trc;
572
2/2
✓ Branch 0 taken 532241 times.
✓ Branch 1 taken 268268 times.
 800509 if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
573 532241 frame->colorspace = avctx->colorspace;
574
2/2
✓ Branch 0 taken 718893 times.
✓ Branch 1 taken 81616 times.
 800509 if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
575 718893 frame->color_range = avctx->color_range;
576
2/2
✓ Branch 0 taken 772961 times.
✓ Branch 1 taken 27548 times.
 800509 if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
577 772961 frame->chroma_location = avctx->chroma_sample_location;
578
579
2/2
✓ Branch 0 taken 277842 times.
✓ Branch 1 taken 522667 times.
 800509 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
580
2/2
✓ Branch 0 taken 261740 times.
✓ Branch 1 taken 16102 times.
 277842 if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
581
2/2
✓ Branch 0 taken 137942 times.
✓ Branch 1 taken 139900 times.
 277842 if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
582
1/2
✓ Branch 0 taken 522667 times.
✗ Branch 1 not taken.
 522667 } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
583
2/2
✓ Branch 0 taken 261426 times.
✓ Branch 1 taken 261241 times.
 522667 if (frame->format == AV_SAMPLE_FMT_NONE)
584 261426 frame->format = avctx->sample_fmt;
585
2/2
✓ Branch 0 taken 261426 times.
✓ Branch 1 taken 261241 times.
 522667 if (!frame->ch_layout.nb_channels) {
586 261426 ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
587
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 261426 times.
 261426 if (ret < 0)
588 ✗ return ret;
589 }
590
2/2
✓ Branch 0 taken 261286 times.
✓ Branch 1 taken 261381 times.
 522667 if (!frame->sample_rate)
591 261286 frame->sample_rate = avctx->sample_rate;
592 }
593
594 800509 return 0;
595 }
596
597 757436 static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
598 {
599 int ret;
600 757436 int64_t discarded_samples = 0;
601
602
2/2
✓ Branch 0 taken 768741 times.
✓ Branch 1 taken 387855 times.
 1156596 while (!frame->buf[0]) {
603
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 768741 times.
 768741 if (discarded_samples > avctx->max_samples)
604 ✗ return AVERROR(EAGAIN);
605 768741 ret = decode_simple_internal(avctx, frame, &discarded_samples);
606
2/2
✓ Branch 0 taken 369581 times.
✓ Branch 1 taken 399160 times.
 768741 if (ret < 0)
607 369581 return ret;
608 }
609
610 387855 return 0;
611 }
612
613 780546 int ff_decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
614 {
615 780546 AVCodecInternal *avci = avctx->internal;
616 780546 DecodeContext *dc = decode_ctx(avci);
617 780546 const FFCodec *const codec = ffcodec(avctx->codec);
618 int ret;
619
620
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 780546 times.
 780546 av_assert0(!frame->buf[0]);
621
622
2/2
✓ Branch 0 taken 23110 times.
✓ Branch 1 taken 757436 times.
 780546 if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) {
623 while (1) {
624 23112 frame->pict_type = dc->initial_pict_type;
625 23112 frame->flags |= dc->intra_only_flag;
626 23112 ret = codec->cb.receive_frame(avctx, frame);
627 23112 emms_c();
628
2/2
✓ Branch 0 taken 11217 times.
✓ Branch 1 taken 11895 times.
 23112 if (!ret) {
629
2/2
✓ Branch 0 taken 1809 times.
✓ Branch 1 taken 9408 times.
 11217 if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
630 1809 int64_t discarded_samples = 0;
631 1809 ret = discard_samples(avctx, frame, &discarded_samples);
632 }
633
3/4
✓ Branch 0 taken 11217 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 11215 times.
 11217 if (ret == AVERROR(EAGAIN) || (frame->flags & AV_FRAME_FLAG_DISCARD)) {
634 2 av_frame_unref(frame);
635 2 continue;
636 }
637 }
638 23110 break;
639 }
640 } else
641 757436 ret = decode_simple_receive_frame(avctx, frame);
642
643
2/2
✓ Branch 0 taken 3421 times.
✓ Branch 1 taken 777125 times.
 780546 if (ret == AVERROR_EOF)
644 3421 avci->draining_done = 1;
645
646 780546 return ret;
647 }
648
649 780234 static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
650 {
651 780234 AVCodecInternal *avci = avctx->internal;
652 780234 DecodeContext *dc = decode_ctx(avci);
653 int ret, ok;
654
655
2/2
✓ Branch 0 taken 832 times.
✓ Branch 1 taken 779402 times.
 780234 if (avctx->active_thread_type & FF_THREAD_FRAME)
656 832 ret = ff_thread_receive_frame(avctx, frame);
657 else
658 779402 ret = ff_decode_receive_frame_internal(avctx, frame);
659
660 /* preserve ret */
661 780234 ok = detect_colorspace(avctx, frame);
662
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 780234 times.
 780234 if (ok < 0) {
663 ✗ av_frame_unref(frame);
664 ✗ return ok;
665 }
666
667
2/2
✓ Branch 0 taken 399069 times.
✓ Branch 1 taken 381165 times.
 780234 if (!ret) {
668
2/2
✓ Branch 0 taken 137854 times.
✓ Branch 1 taken 261215 times.
 399069 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
669
2/2
✓ Branch 0 taken 24044 times.
✓ Branch 1 taken 113810 times.
 137854 if (!frame->width)
670 24044 frame->width = avctx->width;
671
2/2
✓ Branch 0 taken 24044 times.
✓ Branch 1 taken 113810 times.
 137854 if (!frame->height)
672 24044 frame->height = avctx->height;
673 }
674
675 399069 ret = fill_frame_props(avctx, frame);
676
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 399069 times.
 399069 if (ret < 0) {
677 ✗ av_frame_unref(frame);
678 ✗ return ret;
679 }
680
681 #if FF_API_FRAME_KEY
682 FF_DISABLE_DEPRECATION_WARNINGS
683 399069 frame->key_frame = !!(frame->flags & AV_FRAME_FLAG_KEY);
684 FF_ENABLE_DEPRECATION_WARNINGS
685 #endif
686 #if FF_API_INTERLACED_FRAME
687 FF_DISABLE_DEPRECATION_WARNINGS
688 399069 frame->interlaced_frame = !!(frame->flags & AV_FRAME_FLAG_INTERLACED);
689 399069 frame->top_field_first = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
690 FF_ENABLE_DEPRECATION_WARNINGS
691 #endif
692 399069 frame->best_effort_timestamp = guess_correct_pts(dc,
693 frame->pts,
694 frame->pkt_dts);
695
696 /* the only case where decode data is not set should be decoders
697 * that do not call ff_get_buffer() */
698
4/6
✓ Branch 0 taken 374307 times.
✓ Branch 1 taken 24762 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 374307 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 24762 times.
 399069 av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
699 !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
700
701
2/2
✓ Branch 0 taken 374307 times.
✓ Branch 1 taken 24762 times.
 399069 if (frame->private_ref) {
702 374307 FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
703
704
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 374307 times.
 374307 if (fdd->post_process) {
705 ✗ ret = fdd->post_process(avctx, frame);
706 ✗ if (ret < 0) {
707 ✗ av_frame_unref(frame);
708 ✗ return ret;
709 }
710 }
711 }
712 }
713
714 /* free the per-frame decode data */
715 780234 av_buffer_unref(&frame->private_ref);
716
717 780234 return ret;
718 }
719
720 384102 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
721 {
722 384102 AVCodecInternal *avci = avctx->internal;
723 384102 DecodeContext *dc = decode_ctx(avci);
724 int ret;
725
726
2/4
✓ Branch 1 taken 384102 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 384102 times.
 384102 if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
727 ✗ return AVERROR(EINVAL);
728
729
2/2
✓ Branch 0 taken 30 times.
✓ Branch 1 taken 384072 times.
 384102 if (dc->draining_started)
730 30 return AVERROR_EOF;
731
732
5/6
✓ Branch 0 taken 380803 times.
✓ Branch 1 taken 3269 times.
✓ Branch 2 taken 94 times.
✓ Branch 3 taken 380709 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 94 times.
 384072 if (avpkt && !avpkt->size && avpkt->data)
733 ✗ return AVERROR(EINVAL);
734
735
5/6
✓ Branch 0 taken 380803 times.
✓ Branch 1 taken 3269 times.
✓ Branch 2 taken 94 times.
✓ Branch 3 taken 380709 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 94 times.
 384072 if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
736
2/4
✓ Branch 0 taken 380709 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 380709 times.
 380709 if (!AVPACKET_IS_EMPTY(avci->buffer_pkt))
737 ✗ return AVERROR(EAGAIN);
738 380709 ret = av_packet_ref(avci->buffer_pkt, avpkt);
739
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380709 times.
 380709 if (ret < 0)
740 ✗ return ret;
741 } else
742 3363 dc->draining_started = 1;
743
744
3/4
✓ Branch 0 taken 384072 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 380709 times.
✓ Branch 3 taken 3363 times.
 384072 if (!avci->buffer_frame->buf[0] && !dc->draining_started) {
745 380709 ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
746
5/6
✓ Branch 0 taken 11161 times.
✓ Branch 1 taken 369548 times.
✓ Branch 2 taken 635 times.
✓ Branch 3 taken 10526 times.
✓ Branch 4 taken 635 times.
✗ Branch 5 not taken.
 380709 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
747 635 return ret;
748 }
749
750 383437 return 0;
751 }
752
753 137854 static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
754 {
755 /* make sure we are noisy about decoders returning invalid cropping data */
756
1/2
✓ Branch 0 taken 137854 times.
✗ Branch 1 not taken.
 137854 if (frame->crop_left >= INT_MAX - frame->crop_right ||
757
1/2
✓ Branch 0 taken 137854 times.
✗ Branch 1 not taken.
 137854 frame->crop_top >= INT_MAX - frame->crop_bottom ||
758
1/2
✓ Branch 0 taken 137854 times.
✗ Branch 1 not taken.
 137854 (frame->crop_left + frame->crop_right) >= frame->width ||
759
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 137854 times.
 137854 (frame->crop_top + frame->crop_bottom) >= frame->height) {
760 ✗ av_log(avctx, AV_LOG_WARNING,
761 "Invalid cropping information set by a decoder: "
762 "%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER" "
763 "(frame size %dx%d). This is a bug, please report it\n",
764 frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
765 frame->width, frame->height);
766 ✗ frame->crop_left = 0;
767 ✗ frame->crop_right = 0;
768 ✗ frame->crop_top = 0;
769 ✗ frame->crop_bottom = 0;
770 ✗ return 0;
771 }
772
773
2/2
✓ Branch 0 taken 130526 times.
✓ Branch 1 taken 7328 times.
 137854 if (!avctx->apply_cropping)
774 130526 return 0;
775
776 7328 return av_frame_apply_cropping(frame, avctx->flags & AV_CODEC_FLAG_UNALIGNED ?
777 AV_FRAME_CROP_UNALIGNED : 0);
778 }
779
780 // make sure frames returned to the caller are valid
781 399069 static int frame_validate(AVCodecContext *avctx, AVFrame *frame)
782 {
783
2/4
✓ Branch 0 taken 399069 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 399069 times.
 399069 if (!frame->buf[0] || frame->format < 0)
784 ✗ goto fail;
785
786
2/3
✓ Branch 0 taken 137854 times.
✓ Branch 1 taken 261215 times.
✗ Branch 2 not taken.
 399069 switch (avctx->codec_type) {
787 137854 case AVMEDIA_TYPE_VIDEO:
788
2/4
✓ Branch 0 taken 137854 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 137854 times.
 137854 if (frame->width <= 0 || frame->height <= 0)
789 ✗ goto fail;
790 137854 break;
791 261215 case AVMEDIA_TYPE_AUDIO:
792
1/2
✓ Branch 1 taken 261215 times.
✗ Branch 2 not taken.
 261215 if (!av_channel_layout_check(&frame->ch_layout) ||
793
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 261215 times.
 261215 frame->sample_rate <= 0)
794 ✗ goto fail;
795
796 261215 break;
797 ✗ default: av_assert0(0);
798 }
799
800 399069 return 0;
801 ✗ fail:
802 ✗ av_log(avctx, AV_LOG_ERROR, "An invalid frame was output by a decoder. "
803 "This is a bug, please report it.\n");
804 ✗ return AVERROR_BUG;
805 }
806
807 769073 int ff_decode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
808 {
809 769073 AVCodecInternal *avci = avctx->internal;
810 int ret;
811
812
2/4
✓ Branch 1 taken 769073 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 769073 times.
 769073 if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
813 ✗ return AVERROR(EINVAL);
814
815
2/2
✓ Branch 0 taken 369548 times.
✓ Branch 1 taken 399525 times.
 769073 if (avci->buffer_frame->buf[0]) {
816 369548 av_frame_move_ref(frame, avci->buffer_frame);
817 } else {
818 399525 ret = decode_receive_frame_internal(avctx, frame);
819
2/2
✓ Branch 0 taken 370004 times.
✓ Branch 1 taken 29521 times.
 399525 if (ret < 0)
820 370004 return ret;
821 }
822
823 399069 ret = frame_validate(avctx, frame);
824
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 399069 times.
 399069 if (ret < 0)
825 ✗ goto fail;
826
827
2/2
✓ Branch 0 taken 137854 times.
✓ Branch 1 taken 261215 times.
 399069 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
828 137854 ret = apply_cropping(avctx, frame);
829
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 137854 times.
 137854 if (ret < 0)
830 ✗ goto fail;
831 }
832
833 399069 avctx->frame_num++;
834
835 #if FF_API_DROPCHANGED
836
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 399069 times.
 399069 if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
837
838 ✗ if (avctx->frame_num == 1) {
839 ✗ avci->initial_format = frame->format;
840 ✗ switch(avctx->codec_type) {
841 ✗ case AVMEDIA_TYPE_VIDEO:
842 ✗ avci->initial_width = frame->width;
843 ✗ avci->initial_height = frame->height;
844 ✗ break;
845 ✗ case AVMEDIA_TYPE_AUDIO:
846 ✗ avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
847 avctx->sample_rate;
848 ✗ ret = av_channel_layout_copy(&avci->initial_ch_layout, &frame->ch_layout);
849 ✗ if (ret < 0)
850 ✗ goto fail;
851 ✗ break;
852 }
853 }
854
855 ✗ if (avctx->frame_num > 1) {
856 ✗ int changed = avci->initial_format != frame->format;
857
858 ✗ switch(avctx->codec_type) {
859 ✗ case AVMEDIA_TYPE_VIDEO:
860 ✗ changed |= avci->initial_width != frame->width ||
861 ✗ avci->initial_height != frame->height;
862 ✗ break;
863 ✗ case AVMEDIA_TYPE_AUDIO:
864 ✗ changed |= avci->initial_sample_rate != frame->sample_rate ||
865 ✗ avci->initial_sample_rate != avctx->sample_rate ||
866 ✗ av_channel_layout_compare(&avci->initial_ch_layout, &frame->ch_layout);
867 ✗ break;
868 }
869
870 ✗ if (changed) {
871 ✗ avci->changed_frames_dropped++;
872 ✗ av_log(avctx, AV_LOG_INFO, "dropped changed frame #%"PRId64" pts %"PRId64
873 " drop count: %d \n",
874 avctx->frame_num, frame->pts,
875 avci->changed_frames_dropped);
876 ✗ ret = AVERROR_INPUT_CHANGED;
877 ✗ goto fail;
878 }
879 }
880 }
881 #endif
882 399069 return 0;
883 ✗ fail:
884 ✗ av_frame_unref(frame);
885 ✗ return ret;
886 }
887
888 1709 static void get_subtitle_defaults(AVSubtitle *sub)
889 {
890 1709 memset(sub, 0, sizeof(*sub));
891 1709 sub->pts = AV_NOPTS_VALUE;
892 1709 }
893
894 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
895 1675 static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt,
896 const AVPacket *inpkt, AVPacket *buf_pkt)
897 {
898 #if CONFIG_ICONV
899 1675 iconv_t cd = (iconv_t)-1;
900 1675 int ret = 0;
901 char *inb, *outb;
902 size_t inl, outl;
903 #endif
904
905
3/4
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 1582 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
 1675 if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
906 1582 *outpkt = inpkt;
907 1582 return 0;
908 }
909
910 #if CONFIG_ICONV
911 93 inb = inpkt->data;
912 93 inl = inpkt->size;
913
914
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
 93 if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
915 ✗ av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
916 ✗ return AVERROR(ERANGE);
917 }
918
919 93 cd = iconv_open("UTF-8", avctx->sub_charenc);
920
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
 93 av_assert0(cd != (iconv_t)-1);
921
922 93 ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
923
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
 93 if (ret < 0)
924 ✗ goto end;
925 93 ret = av_packet_copy_props(buf_pkt, inpkt);
926
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
 93 if (ret < 0)
927 ✗ goto end;
928 93 outb = buf_pkt->data;
929 93 outl = buf_pkt->size;
930
931
2/4
✓ Branch 1 taken 93 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
✗ Branch 4 not taken.
 186 if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
932 93 iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
933
2/4
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
 93 outl >= buf_pkt->size || inl != 0) {
934 ✗ ret = FFMIN(AVERROR(errno), -1);
935 ✗ av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
936 ✗ "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
937 ✗ goto end;
938 }
939 93 buf_pkt->size -= outl;
940 93 memset(buf_pkt->data + buf_pkt->size, 0, outl);
941 93 *outpkt = buf_pkt;
942
943 93 ret = 0;
944 93 end:
945
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
 93 if (ret < 0)
946 ✗ av_packet_unref(buf_pkt);
947
1/2
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
 93 if (cd != (iconv_t)-1)
948 93 iconv_close(cd);
949 93 return ret;
950 #else
951 av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
952 return AVERROR(EINVAL);
953 #endif
954 }
955
956 700 static int utf8_check(const uint8_t *str)
957 {
958 const uint8_t *byte;
959 uint32_t codepoint, min;
960
961
2/2
✓ Branch 0 taken 61070 times.
✓ Branch 1 taken 700 times.
 61770 while (*str) {
962 61070 byte = str;
963
5/8
✓ Branch 0 taken 61070 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 61070 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2798 times.
✓ Branch 6 taken 2798 times.
✓ Branch 7 taken 61070 times.
 63868 GET_UTF8(codepoint, *(byte++), return 0;);
964
4/4
✓ Branch 0 taken 2091 times.
✓ Branch 1 taken 58979 times.
✓ Branch 2 taken 707 times.
✓ Branch 3 taken 1384 times.
 61777 min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
965 707 1 << (5 * (byte - str) - 4);
966
3/6
✓ Branch 0 taken 61070 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 61070 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 61070 times.
✗ Branch 5 not taken.
 61070 if (codepoint < min || codepoint >= 0x110000 ||
967
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 61070 times.
 61070 codepoint == 0xFFFE /* BOM */ ||
968 ✗ codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
969 ✗ return 0;
970 61070 str = byte;
971 }
972 700 return 1;
973 }
974
975 1709 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
976 int *got_sub_ptr, const AVPacket *avpkt)
977 {
978 1709 int ret = 0;
979
980
3/4
✓ Branch 0 taken 40 times.
✓ Branch 1 taken 1669 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 40 times.
 1709 if (!avpkt->data && avpkt->size) {
981 ✗ av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
982 ✗ return AVERROR(EINVAL);
983 }
984
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1709 times.
 1709 if (!avctx->codec)
985 ✗ return AVERROR(EINVAL);
986
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1709 times.
 1709 if (ffcodec(avctx->codec)->cb_type != FF_CODEC_CB_TYPE_DECODE_SUB) {
987 ✗ av_log(avctx, AV_LOG_ERROR, "Codec not subtitle decoder\n");
988 ✗ return AVERROR(EINVAL);
989 }
990
991 1709 *got_sub_ptr = 0;
992 1709 get_subtitle_defaults(sub);
993
994
4/4
✓ Branch 0 taken 857 times.
✓ Branch 1 taken 852 times.
✓ Branch 2 taken 823 times.
✓ Branch 3 taken 34 times.
 1709 if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
995 1675 AVCodecInternal *avci = avctx->internal;
996 const AVPacket *pkt;
997
998 1675 ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
999
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1675 times.
 1675 if (ret < 0)
1000 79 return ret;
1001
1002
3/4
✓ Branch 0 taken 1675 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1665 times.
✓ Branch 3 taken 10 times.
 1675 if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
1003 1665 sub->pts = av_rescale_q(avpkt->pts,
1004 1665 avctx->pkt_timebase, AV_TIME_BASE_Q);
1005 1675 ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt);
1006
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 1582 times.
 1675 if (pkt == avci->buffer_pkt) // did we recode?
1007 93 av_packet_unref(avci->buffer_pkt);
1008
2/2
✓ Branch 0 taken 79 times.
✓ Branch 1 taken 1596 times.
 1675 if (ret < 0) {
1009 79 *got_sub_ptr = 0;
1010 79 avsubtitle_free(sub);
1011 79 return ret;
1012 }
1013 av_assert1(!sub->num_rects || *got_sub_ptr);
1014
1015
6/6
✓ Branch 0 taken 826 times.
✓ Branch 1 taken 770 times.
✓ Branch 2 taken 580 times.
✓ Branch 3 taken 246 times.
✓ Branch 4 taken 528 times.
✓ Branch 5 taken 52 times.
 1596 if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
1016
1/2
✓ Branch 0 taken 528 times.
✗ Branch 1 not taken.
 528 avctx->pkt_timebase.num) {
1017 528 AVRational ms = { 1, 1000 };
1018 528 sub->end_display_time = av_rescale_q(avpkt->duration,
1019 avctx->pkt_timebase, ms);
1020 }
1021
1022
2/2
✓ Branch 0 taken 156 times.
✓ Branch 1 taken 1440 times.
 1596 if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB)
1023 156 sub->format = 0;
1024
1/2
✓ Branch 0 taken 1440 times.
✗ Branch 1 not taken.
 1440 else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
1025 1440 sub->format = 1;
1026
1027
2/2
✓ Branch 0 taken 859 times.
✓ Branch 1 taken 1596 times.
 2455 for (unsigned i = 0; i < sub->num_rects; i++) {
1028
1/2
✓ Branch 0 taken 859 times.
✗ Branch 1 not taken.
 859 if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_IGNORE &&
1029
3/4
✓ Branch 0 taken 700 times.
✓ Branch 1 taken 159 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 700 times.
 859 sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
1030 ✗ av_log(avctx, AV_LOG_ERROR,
1031 "Invalid UTF-8 in decoded subtitles text; "
1032 "maybe missing -sub_charenc option\n");
1033 ✗ avsubtitle_free(sub);
1034 ✗ *got_sub_ptr = 0;
1035 ✗ return AVERROR_INVALIDDATA;
1036 }
1037 }
1038
1039
2/2
✓ Branch 0 taken 835 times.
✓ Branch 1 taken 761 times.
 1596 if (*got_sub_ptr)
1040 835 avctx->frame_num++;
1041 }
1042
1043 1630 return ret;
1044 }
1045
1046 1494 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx,
1047 const enum AVPixelFormat *fmt)
1048 {
1049 const AVPixFmtDescriptor *desc;
1050 const AVCodecHWConfig *config;
1051 int i, n;
1052
1053 // If a device was supplied when the codec was opened, assume that the
1054 // user wants to use it.
1055
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1494 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1494 if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) {
1056 ✗ AVHWDeviceContext *device_ctx =
1057 ✗ (AVHWDeviceContext*)avctx->hw_device_ctx->data;
1058 ✗ for (i = 0;; i++) {
1059 ✗ config = &ffcodec(avctx->codec)->hw_configs[i]->public;
1060 ✗ if (!config)
1061 ✗ break;
1062 ✗ if (!(config->methods &
1063 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
1064 ✗ continue;
1065 ✗ if (device_ctx->type != config->device_type)
1066 ✗ continue;
1067 ✗ for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1068 ✗ if (config->pix_fmt == fmt[n])
1069 ✗ return fmt[n];
1070 }
1071 }
1072 }
1073 // No device or other setup, so we have to choose from things which
1074 // don't any other external information.
1075
1076 // If the last element of the list is a software format, choose it
1077 // (this should be best software format if any exist).
1078
2/2
✓ Branch 0 taken 3872 times.
✓ Branch 1 taken 1494 times.
 5366 for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1079 1494 desc = av_pix_fmt_desc_get(fmt[n - 1]);
1080
1/2
✓ Branch 0 taken 1494 times.
✗ Branch 1 not taken.
 1494 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1081 1494 return fmt[n - 1];
1082
1083 // Finally, traverse the list in order and choose the first entry
1084 // with no external dependencies (if there is no hardware configuration
1085 // information available then this just picks the first entry).
1086 ✗ for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1087 ✗ for (i = 0;; i++) {
1088 ✗ config = avcodec_get_hw_config(avctx->codec, i);
1089 ✗ if (!config)
1090 ✗ break;
1091 ✗ if (config->pix_fmt == fmt[n])
1092 ✗ break;
1093 }
1094 ✗ if (!config) {
1095 // No specific config available, so the decoder must be able
1096 // to handle this format without any additional setup.
1097 ✗ return fmt[n];
1098 }
1099 ✗ if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1100 // Usable with only internal setup.
1101 ✗ return fmt[n];
1102 }
1103 }
1104
1105 // Nothing is usable, give up.
1106 ✗ return AV_PIX_FMT_NONE;
1107 }
1108
1109 ✗ int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx,
1110 enum AVHWDeviceType dev_type)
1111 {
1112 AVHWDeviceContext *device_ctx;
1113 AVHWFramesContext *frames_ctx;
1114 int ret;
1115
1116 ✗ if (!avctx->hwaccel)
1117 ✗ return AVERROR(ENOSYS);
1118
1119 ✗ if (avctx->hw_frames_ctx)
1120 ✗ return 0;
1121 ✗ if (!avctx->hw_device_ctx) {
1122 ✗ av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1123 "required for hardware accelerated decoding.\n");
1124 ✗ return AVERROR(EINVAL);
1125 }
1126
1127 ✗ device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1128 ✗ if (device_ctx->type != dev_type) {
1129 ✗ av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1130 "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1131 av_hwdevice_get_type_name(device_ctx->type));
1132 ✗ return AVERROR(EINVAL);
1133 }
1134
1135 ✗ ret = avcodec_get_hw_frames_parameters(avctx,
1136 avctx->hw_device_ctx,
1137 ✗ avctx->hwaccel->pix_fmt,
1138 &avctx->hw_frames_ctx);
1139 ✗ if (ret < 0)
1140 ✗ return ret;
1141
1142 ✗ frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1143
1144
1145 ✗ if (frames_ctx->initial_pool_size) {
1146 // We guarantee 4 base work surfaces. The function above guarantees 1
1147 // (the absolute minimum), so add the missing count.
1148 ✗ frames_ctx->initial_pool_size += 3;
1149 }
1150
1151 ✗ ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
1152 ✗ if (ret < 0) {
1153 ✗ av_buffer_unref(&avctx->hw_frames_ctx);
1154 ✗ return ret;
1155 }
1156
1157 ✗ return 0;
1158 }
1159
1160 ✗ int avcodec_get_hw_frames_parameters(AVCodecContext *avctx,
1161 AVBufferRef *device_ref,
1162 enum AVPixelFormat hw_pix_fmt,
1163 AVBufferRef **out_frames_ref)
1164 {
1165 ✗ AVBufferRef *frames_ref = NULL;
1166 const AVCodecHWConfigInternal *hw_config;
1167 const FFHWAccel *hwa;
1168 int i, ret;
1169
1170 ✗ for (i = 0;; i++) {
1171 ✗ hw_config = ffcodec(avctx->codec)->hw_configs[i];
1172 ✗ if (!hw_config)
1173 ✗ return AVERROR(ENOENT);
1174 ✗ if (hw_config->public.pix_fmt == hw_pix_fmt)
1175 ✗ break;
1176 }
1177
1178 ✗ hwa = hw_config->hwaccel;
1179 ✗ if (!hwa || !hwa->frame_params)
1180 ✗ return AVERROR(ENOENT);
1181
1182 ✗ frames_ref = av_hwframe_ctx_alloc(device_ref);
1183 ✗ if (!frames_ref)
1184 ✗ return AVERROR(ENOMEM);
1185
1186 ✗ if (!avctx->internal->hwaccel_priv_data) {
1187 ✗ avctx->internal->hwaccel_priv_data =
1188 ✗ av_mallocz(hwa->priv_data_size);
1189 ✗ if (!avctx->internal->hwaccel_priv_data) {
1190 ✗ av_buffer_unref(&frames_ref);
1191 ✗ return AVERROR(ENOMEM);
1192 }
1193 }
1194
1195 ✗ ret = hwa->frame_params(avctx, frames_ref);
1196 ✗ if (ret >= 0) {
1197 ✗ AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1198
1199 ✗ if (frames_ctx->initial_pool_size) {
1200 // If the user has requested that extra output surfaces be
1201 // available then add them here.
1202 ✗ if (avctx->extra_hw_frames > 0)
1203 ✗ frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1204
1205 // If frame threading is enabled then an extra surface per thread
1206 // is also required.
1207 ✗ if (avctx->active_thread_type & FF_THREAD_FRAME)
1208 ✗ frames_ctx->initial_pool_size += avctx->thread_count;
1209 }
1210
1211 ✗ *out_frames_ref = frames_ref;
1212 } else {
1213 ✗ av_buffer_unref(&frames_ref);
1214 }
1215 ✗ return ret;
1216 }
1217
1218 ✗ static int hwaccel_init(AVCodecContext *avctx,
1219 const FFHWAccel *hwaccel)
1220 {
1221 int err;
1222
1223 ✗ if (hwaccel->p.capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1224 ✗ avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1225 ✗ av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1226 ✗ hwaccel->p.name);
1227 ✗ return AVERROR_PATCHWELCOME;
1228 }
1229
1230 ✗ if (!avctx->internal->hwaccel_priv_data && hwaccel->priv_data_size) {
1231 ✗ avctx->internal->hwaccel_priv_data =
1232 ✗ av_mallocz(hwaccel->priv_data_size);
1233 ✗ if (!avctx->internal->hwaccel_priv_data)
1234 ✗ return AVERROR(ENOMEM);
1235 }
1236
1237 ✗ avctx->hwaccel = &hwaccel->p;
1238 ✗ if (hwaccel->init) {
1239 ✗ err = hwaccel->init(avctx);
1240 ✗ if (err < 0) {
1241 ✗ av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1242 "hwaccel initialisation returned error.\n",
1243 ✗ av_get_pix_fmt_name(hwaccel->p.pix_fmt));
1244 ✗ av_freep(&avctx->internal->hwaccel_priv_data);
1245 ✗ avctx->hwaccel = NULL;
1246 ✗ return err;
1247 }
1248 }
1249
1250 ✗ return 0;
1251 }
1252
1253 36535 void ff_hwaccel_uninit(AVCodecContext *avctx)
1254 {
1255
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 36535 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 36535 if (FF_HW_HAS_CB(avctx, uninit))
1256 ✗ FF_HW_SIMPLE_CALL(avctx, uninit);
1257
1258 36535 av_freep(&avctx->internal->hwaccel_priv_data);
1259
1260 36535 avctx->hwaccel = NULL;
1261
1262 36535 av_buffer_unref(&avctx->hw_frames_ctx);
1263 36535 }
1264
1265 2448 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1266 {
1267 const AVPixFmtDescriptor *desc;
1268 enum AVPixelFormat *choices;
1269 enum AVPixelFormat ret, user_choice;
1270 const AVCodecHWConfigInternal *hw_config;
1271 const AVCodecHWConfig *config;
1272 int i, n, err;
1273
1274 // Find end of list.
1275
2/2
✓ Branch 0 taken 6489 times.
✓ Branch 1 taken 2448 times.
 8937 for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1276 // Must contain at least one entry.
1277
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2448 times.
 2448 av_assert0(n >= 1);
1278 // If a software format is available, it must be the last entry.
1279 2448 desc = av_pix_fmt_desc_get(fmt[n - 1]);
1280
1/2
✓ Branch 0 taken 2448 times.
✗ Branch 1 not taken.
 2448 if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1281 // No software format is available.
1282 } else {
1283 2448 avctx->sw_pix_fmt = fmt[n - 1];
1284 }
1285
1286 2448 choices = av_memdup(fmt, (n + 1) * sizeof(*choices));
1287
1/2
✓ Branch 0 taken 2448 times.
✗ Branch 1 not taken.
 2448 if (!choices)
1288 ✗ return AV_PIX_FMT_NONE;
1289
1290 for (;;) {
1291 // Remove the previous hwaccel, if there was one.
1292 2448 ff_hwaccel_uninit(avctx);
1293
1294 2448 user_choice = avctx->get_format(avctx, choices);
1295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2448 times.
 2448 if (user_choice == AV_PIX_FMT_NONE) {
1296 // Explicitly chose nothing, give up.
1297 ✗ ret = AV_PIX_FMT_NONE;
1298 ✗ break;
1299 }
1300
1301 2448 desc = av_pix_fmt_desc_get(user_choice);
1302
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2448 times.
 2448 if (!desc) {
1303 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1304 "get_format() callback.\n");
1305 ✗ ret = AV_PIX_FMT_NONE;
1306 ✗ break;
1307 }
1308 2448 av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1309 2448 desc->name);
1310
1311
1/2
✓ Branch 0 taken 6489 times.
✗ Branch 1 not taken.
 6489 for (i = 0; i < n; i++) {
1312
2/2
✓ Branch 0 taken 2448 times.
✓ Branch 1 taken 4041 times.
 6489 if (choices[i] == user_choice)
1313 2448 break;
1314 }
1315
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2448 times.
 2448 if (i == n) {
1316 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1317 ✗ "%s not in possible list.\n", desc->name);
1318 ✗ ret = AV_PIX_FMT_NONE;
1319 ✗ break;
1320 }
1321
1322
2/2
✓ Branch 1 taken 2401 times.
✓ Branch 2 taken 47 times.
 2448 if (ffcodec(avctx->codec)->hw_configs) {
1323 2401 for (i = 0;; i++) {
1324 6635 hw_config = ffcodec(avctx->codec)->hw_configs[i];
1325
2/2
✓ Branch 0 taken 2401 times.
✓ Branch 1 taken 4234 times.
 6635 if (!hw_config)
1326 2401 break;
1327
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4234 times.
 4234 if (hw_config->public.pix_fmt == user_choice)
1328 ✗ break;
1329 }
1330 } else {
1331 47 hw_config = NULL;
1332 }
1333
1334
1/2
✓ Branch 0 taken 2448 times.
✗ Branch 1 not taken.
 2448 if (!hw_config) {
1335 // No config available, so no extra setup required.
1336 2448 ret = user_choice;
1337 2448 break;
1338 }
1339 ✗ config = &hw_config->public;
1340
1341 ✗ if (config->methods &
1342 ✗ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
1343 ✗ avctx->hw_frames_ctx) {
1344 ✗ const AVHWFramesContext *frames_ctx =
1345 ✗ (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1346 ✗ if (frames_ctx->format != user_choice) {
1347 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1348 "does not match the format of the provided frames "
1349 ✗ "context.\n", desc->name);
1350 ✗ goto try_again;
1351 }
1352 ✗ } else if (config->methods &
1353 ✗ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
1354 ✗ avctx->hw_device_ctx) {
1355 ✗ const AVHWDeviceContext *device_ctx =
1356 ✗ (AVHWDeviceContext*)avctx->hw_device_ctx->data;
1357 ✗ if (device_ctx->type != config->device_type) {
1358 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1359 "does not match the type of the provided device "
1360 ✗ "context.\n", desc->name);
1361 ✗ goto try_again;
1362 }
1363 ✗ } else if (config->methods &
1364 AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1365 // Internal-only setup, no additional configuration.
1366 ✗ } else if (config->methods &
1367 AV_CODEC_HW_CONFIG_METHOD_AD_HOC) {
1368 // Some ad-hoc configuration we can't see and can't check.
1369 } else {
1370 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1371 ✗ "missing configuration.\n", desc->name);
1372 ✗ goto try_again;
1373 }
1374 ✗ if (hw_config->hwaccel) {
1375 ✗ av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel %s "
1376 ✗ "initialisation.\n", desc->name, hw_config->hwaccel->p.name);
1377 ✗ err = hwaccel_init(avctx, hw_config->hwaccel);
1378 ✗ if (err < 0)
1379 ✗ goto try_again;
1380 }
1381 ✗ ret = user_choice;
1382 ✗ break;
1383
1384 ✗ try_again:
1385 ✗ av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1386 ✗ "get_format() without it.\n", desc->name);
1387 ✗ for (i = 0; i < n; i++) {
1388 ✗ if (choices[i] == user_choice)
1389 ✗ break;
1390 }
1391 ✗ for (; i + 1 < n; i++)
1392 ✗ choices[i] = choices[i + 1];
1393 ✗ --n;
1394 }
1395
1396
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2448 times.
 2448 if (ret < 0)
1397 ✗ ff_hwaccel_uninit(avctx);
1398
1399 2448 av_freep(&choices);
1400 2448 return ret;
1401 }
1402
1403 3613420 const AVPacketSideData *ff_get_coded_side_data(const AVCodecContext *avctx,
1404 enum AVPacketSideDataType type)
1405 {
1406
2/2
✓ Branch 0 taken 56197 times.
✓ Branch 1 taken 3611057 times.
 3667254 for (int i = 0; i < avctx->nb_coded_side_data; i++)
1407
2/2
✓ Branch 0 taken 2363 times.
✓ Branch 1 taken 53834 times.
 56197 if (avctx->coded_side_data[i].type == type)
1408 2363 return &avctx->coded_side_data[i];
1409
1410 3611057 return NULL;
1411 }
1412
1413 401440 static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
1414 {
1415 size_t size;
1416 const uint8_t *side_metadata;
1417
1418 401440 AVDictionary **frame_md = &frame->metadata;
1419
1420 401440 side_metadata = av_packet_get_side_data(avpkt,
1421 AV_PKT_DATA_STRINGS_METADATA, &size);
1422 401440 return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1423 }
1424
1425 401440 int ff_decode_frame_props_from_pkt(const AVCodecContext *avctx,
1426 AVFrame *frame, const AVPacket *pkt)
1427 {
1428 static const struct {
1429 enum AVPacketSideDataType packet;
1430 enum AVFrameSideDataType frame;
1431 } sd[] = {
1432 { AV_PKT_DATA_A53_CC, AV_FRAME_DATA_A53_CC },
1433 { AV_PKT_DATA_AFD, AV_FRAME_DATA_AFD },
1434 { AV_PKT_DATA_DYNAMIC_HDR10_PLUS, AV_FRAME_DATA_DYNAMIC_HDR_PLUS },
1435 { AV_PKT_DATA_S12M_TIMECODE, AV_FRAME_DATA_S12M_TIMECODE },
1436 { AV_PKT_DATA_SKIP_SAMPLES, AV_FRAME_DATA_SKIP_SAMPLES },
1437 };
1438
1439 401440 frame->pts = pkt->pts;
1440 401440 frame->duration = pkt->duration;
1441 #if FF_API_FRAME_PKT
1442 FF_DISABLE_DEPRECATION_WARNINGS
1443 401440 frame->pkt_pos = pkt->pos;
1444 401440 frame->pkt_size = pkt->size;
1445 FF_ENABLE_DEPRECATION_WARNINGS
1446 #endif
1447
1448
2/2
✓ Branch 0 taken 3612960 times.
✓ Branch 1 taken 401440 times.
 4014400 for (int i = 0; ff_sd_global_map[i].packet < AV_PKT_DATA_NB; i++) {
1449 size_t size;
1450 3612960 const uint8_t *packet_sd = av_packet_get_side_data(pkt, ff_sd_global_map[i].packet, &size);
1451
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3612960 times.
 3612960 if (packet_sd) {
1452 AVFrameSideData *frame_sd;
1453
1454 ✗ frame_sd = av_frame_new_side_data(frame, ff_sd_global_map[i].frame, size);
1455 ✗ if (!frame_sd)
1456 ✗ return AVERROR(ENOMEM);
1457 ✗ memcpy(frame_sd->data, packet_sd, size);
1458 }
1459 }
1460
2/2
✓ Branch 0 taken 2007200 times.
✓ Branch 1 taken 401440 times.
 2408640 for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1461 size_t size;
1462 2007200 uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1463
2/2
✓ Branch 0 taken 122 times.
✓ Branch 1 taken 2007078 times.
 2007200 if (packet_sd) {
1464 122 AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
1465 122 sd[i].frame,
1466 size);
1467
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 122 times.
 122 if (!frame_sd)
1468 ✗ return AVERROR(ENOMEM);
1469
1470 122 memcpy(frame_sd->data, packet_sd, size);
1471 }
1472 }
1473 401440 add_metadata_from_side_data(pkt, frame);
1474
1475
2/2
✓ Branch 0 taken 209 times.
✓ Branch 1 taken 401231 times.
 401440 if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1476 209 frame->flags |= AV_FRAME_FLAG_DISCARD;
1477 } else {
1478 401231 frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1479 }
1480
1481
2/2
✓ Branch 0 taken 389913 times.
✓ Branch 1 taken 11527 times.
 401440 if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
1482 389913 int ret = av_buffer_replace(&frame->opaque_ref, pkt->opaque_ref);
1483
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 389913 times.
 389913 if (ret < 0)
1484 ✗ return ret;
1485 389913 frame->opaque = pkt->opaque;
1486 }
1487
1488 401440 return 0;
1489 }
1490
1491 401440 int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
1492 {
1493 int ret;
1494
1495
2/2
✓ Branch 0 taken 3612960 times.
✓ Branch 1 taken 401440 times.
 4014400 for (int i = 0; ff_sd_global_map[i].packet < AV_PKT_DATA_NB; i++) {
1496 3612960 const AVPacketSideData *packet_sd = ff_get_coded_side_data(avctx,
1497 3612960 ff_sd_global_map[i].packet);
1498
2/2
✓ Branch 0 taken 2352 times.
✓ Branch 1 taken 3610608 times.
 3612960 if (packet_sd) {
1499 2352 AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
1500 2352 ff_sd_global_map[i].frame,
1501 2352 packet_sd->size);
1502
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2352 times.
 2352 if (!frame_sd)
1503 ✗ return AVERROR(ENOMEM);
1504
1505 2352 memcpy(frame_sd->data, packet_sd->data, packet_sd->size);
1506 }
1507 }
1508
1509
1/2
✓ Branch 1 taken 401440 times.
✗ Branch 2 not taken.
 401440 if (!(ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) {
1510 401440 const AVPacket *pkt = avctx->internal->last_pkt_props;
1511
1512 401440 ret = ff_decode_frame_props_from_pkt(avctx, frame, pkt);
1513
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 401440 times.
 401440 if (ret < 0)
1514 ✗ return ret;
1515 #if FF_API_FRAME_PKT
1516 FF_DISABLE_DEPRECATION_WARNINGS
1517 401440 frame->pkt_size = pkt->stream_index;
1518 FF_ENABLE_DEPRECATION_WARNINGS
1519 #endif
1520 }
1521
1522 401440 ret = fill_frame_props(avctx, frame);
1523
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 401440 times.
 401440 if (ret < 0)
1524 ✗ return ret;
1525
1526
2/2
✓ Branch 0 taken 139988 times.
✓ Branch 1 taken 261452 times.
 401440 switch (avctx->codec->type) {
1527 139988 case AVMEDIA_TYPE_VIDEO:
1528
4/6
✓ Branch 0 taken 115944 times.
✓ Branch 1 taken 24044 times.
✓ Branch 2 taken 115944 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 115944 times.
 255932 if (frame->width && frame->height &&
1529 115944 av_image_check_sar(frame->width, frame->height,
1530 frame->sample_aspect_ratio) < 0) {
1531 ✗ av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1532 frame->sample_aspect_ratio.num,
1533 frame->sample_aspect_ratio.den);
1534 ✗ frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1535 }
1536 139988 break;
1537 }
1538 401440 return 0;
1539 }
1540
1541 375360 static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
1542 {
1543
2/2
✓ Branch 0 taken 113908 times.
✓ Branch 1 taken 261452 times.
 375360 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1544 int i;
1545 113908 int num_planes = av_pix_fmt_count_planes(frame->format);
1546 113908 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
1547
1/2
✓ Branch 0 taken 113908 times.
✗ Branch 1 not taken.
 113908 int flags = desc ? desc->flags : 0;
1548
4/4
✓ Branch 0 taken 13148 times.
✓ Branch 1 taken 100760 times.
✓ Branch 2 taken 4004 times.
✓ Branch 3 taken 9144 times.
 113908 if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1549 4004 num_planes = 2;
1550
2/2
✓ Branch 0 taken 320323 times.
✓ Branch 1 taken 113908 times.
 434231 for (i = 0; i < num_planes; i++) {
1551
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 320323 times.
 320323 av_assert0(frame->data[i]);
1552 }
1553 // For formats without data like hwaccel allow unused pointers to be non-NULL.
1554
3/4
✓ Branch 0 taken 704849 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 590941 times.
✓ Branch 3 taken 113908 times.
 704849 for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1555
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 590941 times.
 590941 if (frame->data[i])
1556 ✗ av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1557 590941 frame->data[i] = NULL;
1558 }
1559 }
1560 375360 }
1561
1562 375360 static void decode_data_free(void *opaque, uint8_t *data)
1563 {
1564 375360 FrameDecodeData *fdd = (FrameDecodeData*)data;
1565
1566
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (fdd->post_process_opaque_free)
1567 ✗ fdd->post_process_opaque_free(fdd->post_process_opaque);
1568
1569
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (fdd->hwaccel_priv_free)
1570 ✗ fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1571
1572 375360 av_freep(&fdd);
1573 375360 }
1574
1575 375360 int ff_attach_decode_data(AVFrame *frame)
1576 {
1577 AVBufferRef *fdd_buf;
1578 FrameDecodeData *fdd;
1579
1580 av_assert1(!frame->private_ref);
1581 375360 av_buffer_unref(&frame->private_ref);
1582
1583 375360 fdd = av_mallocz(sizeof(*fdd));
1584
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (!fdd)
1585 ✗ return AVERROR(ENOMEM);
1586
1587 375360 fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1588 NULL, AV_BUFFER_FLAG_READONLY);
1589
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (!fdd_buf) {
1590 ✗ av_freep(&fdd);
1591 ✗ return AVERROR(ENOMEM);
1592 }
1593
1594 375360 frame->private_ref = fdd_buf;
1595
1596 375360 return 0;
1597 }
1598
1599 375360 int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
1600 {
1601 375360 const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
1602 375360 int override_dimensions = 1;
1603 int ret;
1604
1605
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 375360 times.
 375360 av_assert0(av_codec_is_decoder(avctx->codec));
1606
1607
2/2
✓ Branch 0 taken 113908 times.
✓ Branch 1 taken 261452 times.
 375360 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1608
2/4
✓ Branch 0 taken 113908 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 113908 times.
✗ Branch 3 not taken.
 227816 if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1609
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 113908 times.
 227816 (ret = av_image_check_size2(FFALIGN(avctx->width, STRIDE_ALIGN), avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx)) < 0 || avctx->pix_fmt<0) {
1610 ✗ av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1611 ✗ ret = AVERROR(EINVAL);
1612 ✗ goto fail;
1613 }
1614
1615
3/4
✓ Branch 0 taken 731 times.
✓ Branch 1 taken 113177 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 731 times.
 113908 if (frame->width <= 0 || frame->height <= 0) {
1616 113177 frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1617 113177 frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1618 113177 override_dimensions = 0;
1619 }
1620
1621
4/8
✓ Branch 0 taken 113908 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 113908 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 113908 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 113908 times.
 113908 if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1622 ✗ av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1623 ✗ ret = AVERROR(EINVAL);
1624 ✗ goto fail;
1625 }
1626
1/2
✓ Branch 0 taken 261452 times.
✗ Branch 1 not taken.
 261452 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1627
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 261452 times.
 261452 if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) {
1628 ✗ av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1629 ✗ ret = AVERROR(EINVAL);
1630 ✗ goto fail;
1631 }
1632 }
1633 375360 ret = ff_decode_frame_props(avctx, frame);
1634
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (ret < 0)
1635 ✗ goto fail;
1636
1637
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (hwaccel) {
1638 ✗ if (hwaccel->alloc_frame) {
1639 ✗ ret = hwaccel->alloc_frame(avctx, frame);
1640 ✗ goto end;
1641 }
1642 } else
1643 375360 avctx->sw_pix_fmt = avctx->pix_fmt;
1644
1645 375360 ret = avctx->get_buffer2(avctx, frame, flags);
1646
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (ret < 0)
1647 ✗ goto fail;
1648
1649 375360 validate_avframe_allocation(avctx, frame);
1650
1651 375360 ret = ff_attach_decode_data(frame);
1652
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (ret < 0)
1653 ✗ goto fail;
1654
1655 375360 end:
1656
4/4
✓ Branch 0 taken 261452 times.
✓ Branch 1 taken 113908 times.
✓ Branch 2 taken 731 times.
✓ Branch 3 taken 113177 times.
 375360 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1657
2/2
✓ Branch 1 taken 36170 times.
✓ Branch 2 taken 77007 times.
 113177 !(ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_EXPORTS_CROPPING)) {
1658 77007 frame->width = avctx->width;
1659 77007 frame->height = avctx->height;
1660 }
1661
1662 298353 fail:
1663
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375360 times.
 375360 if (ret < 0) {
1664 ✗ av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1665 ✗ av_frame_unref(frame);
1666 }
1667
1668 375360 return ret;
1669 }
1670
1671 7752 static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
1672 {
1673 AVFrame *tmp;
1674 int ret;
1675
1676
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7752 times.
 7752 av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
1677
1678
5/8
✓ Branch 0 taken 7603 times.
✓ Branch 1 taken 149 times.
✓ Branch 2 taken 7603 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7603 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 7603 times.
 7752 if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1679 ✗ av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1680 ✗ frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1681 ✗ av_frame_unref(frame);
1682 }
1683
1684
2/2
✓ Branch 0 taken 149 times.
✓ Branch 1 taken 7603 times.
 7752 if (!frame->data[0])
1685 149 return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1686
1687
4/4
✓ Branch 0 taken 7602 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 1208 times.
✓ Branch 4 taken 6394 times.
 7603 if ((flags & FF_REGET_BUFFER_FLAG_READONLY) || av_frame_is_writable(frame))
1688 1209 return ff_decode_frame_props(avctx, frame);
1689
1690 6394 tmp = av_frame_alloc();
1691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6394 times.
 6394 if (!tmp)
1692 ✗ return AVERROR(ENOMEM);
1693
1694 6394 av_frame_move_ref(tmp, frame);
1695
1696 6394 ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1697
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6394 times.
 6394 if (ret < 0) {
1698 ✗ av_frame_free(&tmp);
1699 ✗ return ret;
1700 }
1701
1702 6394 av_frame_copy(frame, tmp);
1703 6394 av_frame_free(&tmp);
1704
1705 6394 return 0;
1706 }
1707
1708 7752 int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
1709 {
1710 7752 int ret = reget_buffer_internal(avctx, frame, flags);
1711
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7752 times.
 7752 if (ret < 0)
1712 ✗ av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1713 7752 return ret;
1714 }
1715
1716 typedef struct ProgressInternal {
1717 ThreadProgress progress;
1718 struct AVFrame *f;
1719 } ProgressInternal;
1720
1721 387947 static void check_progress_consistency(const ProgressFrame *f)
1722 {
1723 av_assert1(!!f->f == !!f->progress);
1724 av_assert1(!f->progress || f->progress->f == f->f);
1725 387947 }
1726
1727 15876 static int progress_frame_get(AVCodecContext *avctx, ProgressFrame *f)
1728 {
1729 15876 FFRefStructPool *pool = avctx->internal->progress_frame_pool;
1730
1731 av_assert1(!f->f && !f->progress);
1732
1733 15876 f->progress = ff_refstruct_pool_get(pool);
1734
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15876 times.
 15876 if (!f->progress)
1735 ✗ return AVERROR(ENOMEM);
1736
1737 15876 f->f = f->progress->f;
1738 15876 return 0;
1739 }
1740
1741 15876 int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
1742 {
1743 int ret;
1744
1745 15876 ret = progress_frame_get(avctx, f);
1746
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15876 times.
 15876 if (ret < 0)
1747 ✗ return ret;
1748
1749 15876 ret = ff_thread_get_buffer(avctx, f->progress->f, flags);
1750
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 15876 times.
 15876 if (ret < 0) {
1751 ✗ f->f = NULL;
1752 ✗ ff_refstruct_unref(&f->progress);
1753 ✗ return ret;
1754 }
1755 15876 return 0;
1756 }
1757
1758 38946 void ff_progress_frame_ref(ProgressFrame *dst, const ProgressFrame *src)
1759 {
1760 av_assert1(src->progress && src->f && src->f == src->progress->f);
1761 av_assert1(!dst->f && !dst->progress);
1762 38946 dst->f = src->f;
1763 38946 dst->progress = ff_refstruct_ref(src->progress);
1764 38946 }
1765
1766 347793 void ff_progress_frame_unref(ProgressFrame *f)
1767 {
1768 347793 check_progress_consistency(f);
1769 347793 f->f = NULL;
1770 347793 ff_refstruct_unref(&f->progress);
1771 347793 }
1772
1773 40154 void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)
1774 {
1775
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 40154 times.
 40154 if (dst == src)
1776 ✗ return;
1777 40154 ff_progress_frame_unref(dst);
1778 40154 check_progress_consistency(src);
1779
2/2
✓ Branch 0 taken 38879 times.
✓ Branch 1 taken 1275 times.
 40154 if (src->f)
1780 38879 ff_progress_frame_ref(dst, src);
1781 }
1782
1783 19376 void ff_progress_frame_report(ProgressFrame *f, int n)
1784 {
1785 19376 ff_thread_progress_report(&f->progress->progress, n);
1786 19376 }
1787
1788 2597959 void ff_progress_frame_await(const ProgressFrame *f, int n)
1789 {
1790 2597959 ff_thread_progress_await(&f->progress->progress, n);
1791 2597959 }
1792
1793 #if !HAVE_THREADS
1794 enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset)
1795 {
1796 return FF_THREAD_NO_FRAME_THREADING;
1797 }
1798 #endif /* !HAVE_THREADS */
1799
1800 2480 static av_cold int progress_frame_pool_init_cb(FFRefStructOpaque opaque, void *obj)
1801 {
1802 2480 const AVCodecContext *avctx = opaque.nc;
1803 2480 ProgressInternal *progress = obj;
1804 int ret;
1805
1806 2480 ret = ff_thread_progress_init(&progress->progress, avctx->active_thread_type & FF_THREAD_FRAME);
1807
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2480 times.
 2480 if (ret < 0)
1808 ✗ return ret;
1809
1810 2480 progress->f = av_frame_alloc();
1811
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2480 times.
 2480 if (!progress->f)
1812 ✗ return AVERROR(ENOMEM);
1813
1814 2480 return 0;
1815 }
1816
1817 15876 static void progress_frame_pool_reset_cb(FFRefStructOpaque unused, void *obj)
1818 {
1819 15876 ProgressInternal *progress = obj;
1820
1821 15876 ff_thread_progress_reset(&progress->progress);
1822 15876 av_frame_unref(progress->f);
1823 15876 }
1824
1825 2480 static av_cold void progress_frame_pool_free_entry_cb(FFRefStructOpaque opaque, void *obj)
1826 {
1827 2480 ProgressInternal *progress = obj;
1828
1829 2480 ff_thread_progress_destroy(&progress->progress);
1830 2480 av_frame_free(&progress->f);
1831 2480 }
1832
1833 14608 int ff_decode_preinit(AVCodecContext *avctx)
1834 {
1835 14608 AVCodecInternal *avci = avctx->internal;
1836 14608 DecodeContext *dc = decode_ctx(avci);
1837 14608 int ret = 0;
1838
1839 14608 dc->initial_pict_type = AV_PICTURE_TYPE_NONE;
1840
2/2
✓ Branch 0 taken 11316 times.
✓ Branch 1 taken 3292 times.
 14608 if (avctx->codec_descriptor->props & AV_CODEC_PROP_INTRA_ONLY) {
1841 11316 dc->intra_only_flag = AV_FRAME_FLAG_KEY;
1842
2/2
✓ Branch 0 taken 8052 times.
✓ Branch 1 taken 3264 times.
 11316 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
1843 8052 dc->initial_pict_type = AV_PICTURE_TYPE_I;
1844 }
1845
1846 /* if the decoder init function was already called previously,
1847 * free the already allocated subtitle_header before overwriting it */
1848 14608 av_freep(&avctx->subtitle_header);
1849
1850
2/4
✓ Branch 0 taken 14608 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14608 times.
 14608 if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1851 ✗ av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1852 ✗ avctx->codec->max_lowres);
1853 ✗ avctx->lowres = avctx->codec->max_lowres;
1854 }
1855
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 14602 times.
 14608 if (avctx->sub_charenc) {
1856
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1857 ✗ av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1858 "supported with subtitles codecs\n");
1859 ✗ return AVERROR(EINVAL);
1860
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1861 ✗ av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1862 "subtitles character encoding will be ignored\n",
1863 ✗ avctx->codec_descriptor->name);
1864 ✗ avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
1865 } else {
1866 /* input character encoding is set for a text based subtitle
1867 * codec at this point */
1868
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
1869 6 avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
1870
1871
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
 6 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
1872 #if CONFIG_ICONV
1873 6 iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1874
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (cd == (iconv_t)-1) {
1875 ✗ ret = AVERROR(errno);
1876 ✗ av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1877 "with input character encoding \"%s\"\n", avctx->sub_charenc);
1878 ✗ return ret;
1879 }
1880 6 iconv_close(cd);
1881 #else
1882 av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1883 "conversion needs a libavcodec built with iconv support "
1884 "for this codec\n");
1885 return AVERROR(ENOSYS);
1886 #endif
1887 }
1888 }
1889 }
1890
1891 14608 dc->pts_correction_num_faulty_pts =
1892 14608 dc->pts_correction_num_faulty_dts = 0;
1893 14608 dc->pts_correction_last_pts =
1894 14608 dc->pts_correction_last_dts = INT64_MIN;
1895
1896
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1897 ✗ && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
1898 ✗ av_log(avctx, AV_LOG_WARNING,
1899 "gray decoding requested but not enabled at configuration time\n");
1900
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 14603 times.
 14608 if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1901 5 avctx->export_side_data |= AV_CODEC_EXPORT_DATA_MVS;
1902 }
1903
1904
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if (avctx->nb_side_data_prefer_packet == 1 &&
1905 ✗ avctx->side_data_prefer_packet[0] == -1)
1906 ✗ dc->side_data_pref_mask = ~0ULL;
1907 else {
1908
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 14608 times.
 14612 for (unsigned i = 0; i < avctx->nb_side_data_prefer_packet; i++) {
1909 4 int val = avctx->side_data_prefer_packet[i];
1910
1911
2/4
✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 4 if (val < 0 || val >= AV_PKT_DATA_NB) {
1912 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid side data type: %d\n", val);
1913 ✗ return AVERROR(EINVAL);
1914 }
1915
1916
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 4 times.
 40 for (unsigned j = 0; ff_sd_global_map[j].packet < AV_PKT_DATA_NB; j++) {
1917
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 32 times.
 36 if (ff_sd_global_map[j].packet == val) {
1918 4 val = ff_sd_global_map[j].frame;
1919
1920 // this code will need to be changed when we have more than
1921 // 64 frame side data types
1922
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
 4 if (val >= 64) {
1923 ✗ av_log(avctx, AV_LOG_ERROR, "Side data type too big\n");
1924 ✗ return AVERROR_BUG;
1925 }
1926
1927 4 dc->side_data_pref_mask |= 1ULL << val;
1928 }
1929 }
1930 }
1931 }
1932
1933 14608 avci->in_pkt = av_packet_alloc();
1934 14608 avci->last_pkt_props = av_packet_alloc();
1935
2/4
✓ Branch 0 taken 14608 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14608 times.
 14608 if (!avci->in_pkt || !avci->last_pkt_props)
1936 ✗ return AVERROR(ENOMEM);
1937
1938
2/2
✓ Branch 1 taken 1290 times.
✓ Branch 2 taken 13318 times.
 14608 if (ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_USES_PROGRESSFRAMES) {
1939 1290 avci->progress_frame_pool =
1940 1290 ff_refstruct_pool_alloc_ext(sizeof(ProgressInternal),
1941 FF_REFSTRUCT_POOL_FLAG_FREE_ON_INIT_ERROR,
1942 avctx, progress_frame_pool_init_cb,
1943 progress_frame_pool_reset_cb,
1944 progress_frame_pool_free_entry_cb, NULL);
1945
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1290 times.
 1290 if (!avci->progress_frame_pool)
1946 ✗ return AVERROR(ENOMEM);
1947 }
1948 14608 ret = decode_bsfs_init(avctx);
1949
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if (ret < 0)
1950 ✗ return ret;
1951
1952 #if FF_API_DROPCHANGED
1953
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 14608 times.
 14608 if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED)
1954 ✗ av_log(avctx, AV_LOG_WARNING, "The dropchanged flag is deprecated.\n");
1955 #endif
1956
1957 14608 return 0;
1958 }
1959
1960 /**
1961 * Check side data preference and clear existing side data from frame
1962 * if needed.
1963 *
1964 * @retval 0 side data of this type can be added to frame
1965 * @retval 1 side data of this type should not be added to frame
1966 */
1967 5591 static int side_data_pref(const AVCodecContext *avctx, AVFrameSideData ***sd,
1968 int *nb_sd, enum AVFrameSideDataType type)
1969 {
1970 5591 DecodeContext *dc = decode_ctx(avctx->internal);
1971
1972 // Note: could be skipped for `type` without corresponding packet sd
1973
2/2
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 5571 times.
 5591 if (av_frame_side_data_get(*sd, *nb_sd, type)) {
1974
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
 20 if (dc->side_data_pref_mask & (1ULL << type))
1975 10 return 1;
1976 10 av_frame_side_data_remove(sd, nb_sd, type);
1977 }
1978
1979 5581 return 0;
1980 }
1981
1982
1983 4792 int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame,
1984 enum AVFrameSideDataType type, size_t size,
1985 AVFrameSideData **psd)
1986 {
1987 AVFrameSideData *sd;
1988
1989
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4792 times.
 4792 if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data, type)) {
1990 ✗ if (psd)
1991 ✗ *psd = NULL;
1992 ✗ return 0;
1993 }
1994
1995 4792 sd = av_frame_new_side_data(frame, type, size);
1996
1/2
✓ Branch 0 taken 4792 times.
✗ Branch 1 not taken.
 4792 if (psd)
1997 4792 *psd = sd;
1998
1999
1/2
✓ Branch 0 taken 4792 times.
✗ Branch 1 not taken.
 4792 return sd ? 0 : AVERROR(ENOMEM);
2000 }
2001
2002 756 int ff_frame_new_side_data_from_buf_ext(const AVCodecContext *avctx,
2003 AVFrameSideData ***sd, int *nb_sd,
2004 enum AVFrameSideDataType type,
2005 AVBufferRef **buf)
2006 {
2007 756 int ret = 0;
2008
2009
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 756 times.
 756 if (side_data_pref(avctx, sd, nb_sd, type))
2010 ✗ goto finish;
2011
2012
1/2
✓ Branch 1 taken 756 times.
✗ Branch 2 not taken.
 756 if (!av_frame_side_data_add(sd, nb_sd, type, buf, 0))
2013 ✗ ret = AVERROR(ENOMEM);
2014
2015 756 finish:
2016 756 av_buffer_unref(buf);
2017
2018 756 return ret;
2019 }
2020
2021 746 int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx,
2022 AVFrame *frame, enum AVFrameSideDataType type,
2023 AVBufferRef **buf)
2024 {
2025 746 return ff_frame_new_side_data_from_buf_ext(avctx,
2026 &frame->side_data, &frame->nb_side_data,
2027 type, buf);
2028 }
2029
2030 33 int ff_decode_mastering_display_new_ext(const AVCodecContext *avctx,
2031 AVFrameSideData ***sd, int *nb_sd,
2032 struct AVMasteringDisplayMetadata **mdm)
2033 {
2034 AVBufferRef *buf;
2035 size_t size;
2036
2037
2/2
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 23 times.
 33 if (side_data_pref(avctx, sd, nb_sd, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA)) {
2038 10 *mdm = NULL;
2039 10 return 0;
2040 }
2041
2042 23 *mdm = av_mastering_display_metadata_alloc_size(&size);
2043
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
 23 if (!*mdm)
2044 ✗ return AVERROR(ENOMEM);
2045
2046 23 buf = av_buffer_create((uint8_t *)*mdm, size, NULL, NULL, 0);
2047
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 23 times.
 23 if (!buf) {
2048 ✗ av_freep(mdm);
2049 ✗ return AVERROR(ENOMEM);
2050 }
2051
2052
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 23 times.
 23 if (!av_frame_side_data_add(sd, nb_sd, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA,
2053 &buf, 0)) {
2054 ✗ *mdm = NULL;
2055 ✗ av_buffer_unref(&buf);
2056 ✗ return AVERROR(ENOMEM);
2057 }
2058
2059 23 return 0;
2060 }
2061
2062 2 int ff_decode_mastering_display_new(const AVCodecContext *avctx, AVFrame *frame,
2063 AVMasteringDisplayMetadata **mdm)
2064 {
2065
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2066 AV_FRAME_DATA_MASTERING_DISPLAY_METADATA)) {
2067 ✗ *mdm = NULL;
2068 ✗ return 0;
2069 }
2070
2071 2 *mdm = av_mastering_display_metadata_create_side_data(frame);
2072
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 return *mdm ? 0 : AVERROR(ENOMEM);
2073 }
2074
2075 6 int ff_decode_content_light_new_ext(const AVCodecContext *avctx,
2076 AVFrameSideData ***sd, int *nb_sd,
2077 AVContentLightMetadata **clm)
2078 {
2079 AVBufferRef *buf;
2080 size_t size;
2081
2082
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (side_data_pref(avctx, sd, nb_sd, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL)) {
2083 ✗ *clm = NULL;
2084 ✗ return 0;
2085 }
2086
2087 6 *clm = av_content_light_metadata_alloc(&size);
2088
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!*clm)
2089 ✗ return AVERROR(ENOMEM);
2090
2091 6 buf = av_buffer_create((uint8_t *)*clm, size, NULL, NULL, 0);
2092
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 if (!buf) {
2093 ✗ av_freep(clm);
2094 ✗ return AVERROR(ENOMEM);
2095 }
2096
2097
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 6 if (!av_frame_side_data_add(sd, nb_sd, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL,
2098 &buf, 0)) {
2099 ✗ *clm = NULL;
2100 ✗ av_buffer_unref(&buf);
2101 ✗ return AVERROR(ENOMEM);
2102 }
2103
2104 6 return 0;
2105 }
2106
2107 2 int ff_decode_content_light_new(const AVCodecContext *avctx, AVFrame *frame,
2108 AVContentLightMetadata **clm)
2109 {
2110
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
 2 if (side_data_pref(avctx, &frame->side_data, &frame->nb_side_data,
2111 AV_FRAME_DATA_CONTENT_LIGHT_LEVEL)) {
2112 ✗ *clm = NULL;
2113 ✗ return 0;
2114 }
2115
2116 2 *clm = av_content_light_metadata_create_side_data(frame);
2117
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 return *clm ? 0 : AVERROR(ENOMEM);
2118 }
2119
2120 1676 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
2121 {
2122 size_t size;
2123 1676 const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
2124
2125
3/4
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 1644 times.
✓ Branch 2 taken 32 times.
✗ Branch 3 not taken.
 1676 if (pal && size == AVPALETTE_SIZE) {
2126 32 memcpy(dst, pal, AVPALETTE_SIZE);
2127 32 return 1;
2128
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1644 times.
 1644 } else if (pal) {
2129 ✗ av_log(logctx, AV_LOG_ERROR,
2130 "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
2131 }
2132 1644 return 0;
2133 }
2134
2135 49929 int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
2136 {
2137 49929 const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel);
2138
2139
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 49929 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 49929 if (!hwaccel || !hwaccel->frame_priv_data_size)
2140 49929 return 0;
2141
2142 ✗ av_assert0(!*hwaccel_picture_private);
2143
2144 ✗ if (hwaccel->free_frame_priv) {
2145 AVHWFramesContext *frames_ctx;
2146
2147 ✗ if (!avctx->hw_frames_ctx)
2148 ✗ return AVERROR(EINVAL);
2149
2150 ✗ frames_ctx = (AVHWFramesContext *) avctx->hw_frames_ctx->data;
2151 ✗ *hwaccel_picture_private = ff_refstruct_alloc_ext(hwaccel->frame_priv_data_size, 0,
2152 ✗ frames_ctx->device_ctx,
2153 ✗ hwaccel->free_frame_priv);
2154 } else {
2155 ✗ *hwaccel_picture_private = ff_refstruct_allocz(hwaccel->frame_priv_data_size);
2156 }
2157
2158 ✗ if (!*hwaccel_picture_private)
2159 ✗ return AVERROR(ENOMEM);
2160
2161 ✗ return 0;
2162 }
2163
2164 103 void ff_decode_flush_buffers(AVCodecContext *avctx)
2165 {
2166 103 AVCodecInternal *avci = avctx->internal;
2167 103 DecodeContext *dc = decode_ctx(avci);
2168
2169 103 av_packet_unref(avci->last_pkt_props);
2170 103 av_packet_unref(avci->in_pkt);
2171
2172 103 dc->pts_correction_last_pts =
2173 103 dc->pts_correction_last_dts = INT64_MIN;
2174
2175
1/2
✓ Branch 0 taken 103 times.
✗ Branch 1 not taken.
 103 if (avci->bsf)
2176 103 av_bsf_flush(avci->bsf);
2177
2178 103 dc->nb_draining_errors = 0;
2179 103 dc->draining_started = 0;
2180 103 }
2181
2182 14684 AVCodecInternal *ff_decode_internal_alloc(void)
2183 {
2184 14684 return av_mallocz(sizeof(DecodeContext));
2185 }
2186