FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/decode.c
Date: 2021-09-23 20:34:37
Exec Total Coverage
Lines: 660 1059 62.3%
Branches: 487 837 58.2%

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/avstring.h"
32 #include "libavutil/bprint.h"
33 #include "libavutil/channel_layout.h"
34 #include "libavutil/common.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/hwcontext.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/internal.h"
39 #include "libavutil/intmath.h"
40 #include "libavutil/opt.h"
41
42 #include "avcodec.h"
43 #include "bytestream.h"
44 #include "bsf.h"
45 #include "decode.h"
46 #include "hwconfig.h"
47 #include "internal.h"
48 #include "thread.h"
49
50 typedef struct FramePool {
51 /**
52 * Pools for each data plane. For audio all the planes have the same size,
53 * so only pools[0] is used.
54 */
55 AVBufferPool *pools[4];
56
57 /*
58 * Pool parameters
59 */
60 int format;
61 int width, height;
62 int stride_align[AV_NUM_DATA_POINTERS];
63 int linesize[4];
64 int planes;
65 int channels;
66 int samples;
67 } FramePool;
68
69 375151 static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
70 {
71 int ret;
72 size_t size;
73 const uint8_t *data;
74 uint32_t flags;
75 int64_t val;
76
77 375151 data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
78
2/2
✓ Branch 0 taken 375149 times.
✓ Branch 1 taken 2 times.
375151 if (!data)
79 375149 return 0;
80
81
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
82 av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
83 "changes, but PARAM_CHANGE side data was sent to it.\n");
84 ret = AVERROR(EINVAL);
85 goto fail2;
86 }
87
88
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (size < 4)
89 goto fail;
90
91 2 flags = bytestream_get_le32(&data);
92 2 size -= 4;
93
94
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
95 if (size < 4)
96 goto fail;
97 val = bytestream_get_le32(&data);
98 if (val <= 0 || val > INT_MAX) {
99 av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
100 ret = AVERROR_INVALIDDATA;
101 goto fail2;
102 }
103 avctx->channels = val;
104 size -= 4;
105 }
106
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
107 if (size < 8)
108 goto fail;
109 avctx->channel_layout = bytestream_get_le64(&data);
110 size -= 8;
111 }
112
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
113 if (size < 4)
114 goto fail;
115 val = bytestream_get_le32(&data);
116 if (val <= 0 || val > INT_MAX) {
117 av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
118 ret = AVERROR_INVALIDDATA;
119 goto fail2;
120 }
121 avctx->sample_rate = val;
122 size -= 4;
123 }
124
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
2 if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
125
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (size < 8)
126 goto fail;
127 2 avctx->width = bytestream_get_le32(&data);
128 2 avctx->height = bytestream_get_le32(&data);
129 2 size -= 8;
130 2 ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
131
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (ret < 0)
132 goto fail2;
133 }
134
135 2 return 0;
136 fail:
137 av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
138 ret = AVERROR_INVALIDDATA;
139 fail2:
140 if (ret < 0) {
141 av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
142 if (avctx->err_recognition & AV_EF_EXPLODE)
143 return ret;
144 }
145 return 0;
146 }
147
148 #define IS_EMPTY(pkt) (!(pkt)->data)
149
150 375151 static int copy_packet_props(AVPacket *dst, const AVPacket *src)
151 {
152 375151 int ret = av_packet_copy_props(dst, src);
153
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375151 times.
375151 if (ret < 0)
154 return ret;
155
156 375151 dst->size = src->size; // HACK: Needed for ff_decode_frame_props().
157 375151 dst->data = (void*)1; // HACK: Needed for IS_EMPTY().
158
159 375151 return 0;
160 }
161
162 375151 static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
163 {
164 375151 AVPacket tmp = { 0 };
165 375151 int ret = 0;
166
167
1/2
✓ Branch 0 taken 375151 times.
✗ Branch 1 not taken.
375151 if (IS_EMPTY(avci->last_pkt_props)) {
168
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 375151 times.
375151 if (av_fifo_size(avci->pkt_props) >= sizeof(*pkt)) {
169 av_fifo_generic_read(avci->pkt_props, avci->last_pkt_props,
170 sizeof(*avci->last_pkt_props), NULL);
171 } else
172 375151 return copy_packet_props(avci->last_pkt_props, pkt);
173 }
174
175 if (av_fifo_space(avci->pkt_props) < sizeof(*pkt)) {
176 ret = av_fifo_grow(avci->pkt_props, sizeof(*pkt));
177 if (ret < 0)
178 return ret;
179 }
180
181 ret = copy_packet_props(&tmp, pkt);
182 if (ret < 0)
183 return ret;
184
185 av_fifo_generic_write(avci->pkt_props, &tmp, sizeof(tmp), NULL);
186
187 return 0;
188 }
189
190 12860 static int decode_bsfs_init(AVCodecContext *avctx)
191 {
192 12860 AVCodecInternal *avci = avctx->internal;
193 int ret;
194
195
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12860 times.
12860 if (avci->bsf)
196 return 0;
197
198 12860 ret = av_bsf_list_parse_str(avctx->codec->bsfs, &avci->bsf);
199
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12860 times.
12860 if (ret < 0) {
200 av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", avctx->codec->bsfs, av_err2str(ret));
201 if (ret != AVERROR(ENOMEM))
202 ret = AVERROR_BUG;
203 goto fail;
204 }
205
206 /* We do not currently have an API for passing the input timebase into decoders,
207 * but no filters used here should actually need it.
208 * So we make up some plausible-looking number (the MPEG 90kHz timebase) */
209 12860 avci->bsf->time_base_in = (AVRational){ 1, 90000 };
210 12860 ret = avcodec_parameters_from_context(avci->bsf->par_in, avctx);
211
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12860 times.
12860 if (ret < 0)
212 goto fail;
213
214 12860 ret = av_bsf_init(avci->bsf);
215
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12860 times.
12860 if (ret < 0)
216 goto fail;
217
218 12860 return 0;
219 fail:
220 av_bsf_free(&avci->bsf);
221 return ret;
222 }
223
224 753083 int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
225 {
226 753083 AVCodecInternal *avci = avctx->internal;
227 int ret;
228
229
2/2
✓ Branch 0 taken 61 times.
✓ Branch 1 taken 753022 times.
753083 if (avci->draining)
230 61 return AVERROR_EOF;
231
232 753022 ret = av_bsf_receive_packet(avci->bsf, pkt);
233
2/2
✓ Branch 0 taken 5906 times.
✓ Branch 1 taken 747116 times.
753022 if (ret == AVERROR_EOF)
234 5906 avci->draining = 1;
235
2/2
✓ Branch 0 taken 377871 times.
✓ Branch 1 taken 375151 times.
753022 if (ret < 0)
236 377871 return ret;
237
238
1/2
✓ Branch 0 taken 375151 times.
✗ Branch 1 not taken.
375151 if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) {
239 375151 ret = extract_packet_props(avctx->internal, pkt);
240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375151 times.
375151 if (ret < 0)
241 goto finish;
242 }
243
244 375151 ret = apply_param_change(avctx, pkt);
245
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375151 times.
375151 if (ret < 0)
246 goto finish;
247
248 375151 return 0;
249 finish:
250 av_packet_unref(pkt);
251 return ret;
252 }
253
254 /**
255 * Attempt to guess proper monotonic timestamps for decoded video frames
256 * which might have incorrect times. Input timestamps may wrap around, in
257 * which case the output will as well.
258 *
259 * @param pts the pts field of the decoded AVPacket, as passed through
260 * AVFrame.pts
261 * @param dts the dts field of the decoded AVPacket
262 * @return one of the input values, may be AV_NOPTS_VALUE
263 */
264 395826 static int64_t guess_correct_pts(AVCodecContext *ctx,
265 int64_t reordered_pts, int64_t dts)
266 {
267 395826 int64_t pts = AV_NOPTS_VALUE;
268
269
2/2
✓ Branch 0 taken 360991 times.
✓ Branch 1 taken 34835 times.
395826 if (dts != AV_NOPTS_VALUE) {
270 360991 ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
271 360991 ctx->pts_correction_last_dts = dts;
272
2/2
✓ Branch 0 taken 304 times.
✓ Branch 1 taken 34531 times.
34835 } else if (reordered_pts != AV_NOPTS_VALUE)
273 304 ctx->pts_correction_last_dts = reordered_pts;
274
275
2/2
✓ Branch 0 taken 332411 times.
✓ Branch 1 taken 63415 times.
395826 if (reordered_pts != AV_NOPTS_VALUE) {
276 332411 ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
277 332411 ctx->pts_correction_last_pts = reordered_pts;
278
2/2
✓ Branch 0 taken 28884 times.
✓ Branch 1 taken 34531 times.
63415 } else if(dts != AV_NOPTS_VALUE)
279 28884 ctx->pts_correction_last_pts = dts;
280
281
4/4
✓ Branch 0 taken 561 times.
✓ Branch 1 taken 395265 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 556 times.
395826 if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
282
2/2
✓ Branch 0 taken 331855 times.
✓ Branch 1 taken 63415 times.
395270 && reordered_pts != AV_NOPTS_VALUE)
283 331855 pts = reordered_pts;
284 else
285 63971 pts = dts;
286
287 395826 return pts;
288 }
289
290 /*
291 * The core of the receive_frame_wrapper for the decoders implementing
292 * the simple API. Certain decoders might consume partial packets without
293 * returning any output, so this function needs to be called in a loop until it
294 * returns EAGAIN.
295 **/
296 783511 static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
297 {
298 783511 AVCodecInternal *avci = avctx->internal;
299 783511 DecodeSimpleContext *ds = &avci->ds;
300 783511 AVPacket *pkt = ds->in_pkt;
301 int got_frame, actual_got_frame;
302 int ret;
303
304
4/4
✓ Branch 0 taken 754851 times.
✓ Branch 1 taken 28660 times.
✓ Branch 2 taken 747978 times.
✓ Branch 3 taken 6873 times.
783511 if (!pkt->data && !avci->draining) {
305 747978 av_packet_unref(pkt);
306 747978 ret = ff_decode_get_packet(avctx, pkt);
307
4/4
✓ Branch 0 taken 375465 times.
✓ Branch 1 taken 372513 times.
✓ Branch 2 taken 369620 times.
✓ Branch 3 taken 5845 times.
747978 if (ret < 0 && ret != AVERROR_EOF)
308 369620 return ret;
309 }
310
311 // Some codecs (at least wma lossless) will crash when feeding drain packets
312 // after EOF was signaled.
313
2/2
✓ Branch 0 taken 6144 times.
✓ Branch 1 taken 407747 times.
413891 if (avci->draining_done)
314 6144 return AVERROR_EOF;
315
316
2/2
✓ Branch 0 taken 6574 times.
✓ Branch 1 taken 401173 times.
407747 if (!pkt->data &&
317
2/2
✓ Branch 0 taken 5213 times.
✓ Branch 1 taken 1361 times.
6574 !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
318
2/2
✓ Branch 0 taken 5164 times.
✓ Branch 1 taken 49 times.
5213 avctx->active_thread_type & FF_THREAD_FRAME))
319 5164 return AVERROR_EOF;
320
321 402583 got_frame = 0;
322
323
2/2
✓ Branch 0 taken 582 times.
✓ Branch 1 taken 402001 times.
402583 if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
324 582 ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
325 } else {
326 402001 ret = avctx->codec->decode(avctx, frame, &got_frame, pkt);
327
328
2/2
✓ Branch 0 taken 401671 times.
✓ Branch 1 taken 330 times.
402001 if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS))
329 401671 frame->pkt_dts = pkt->dts;
330
2/2
✓ Branch 0 taken 113857 times.
✓ Branch 1 taken 288144 times.
402001 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
331
2/2
✓ Branch 0 taken 81678 times.
✓ Branch 1 taken 32179 times.
113857 if(!avctx->has_b_frames)
332 81678 frame->pkt_pos = pkt->pos;
333 //FIXME these should be under if(!avctx->has_b_frames)
334 /* get_buffer is supposed to set frame parameters */
335
2/2
✓ Branch 0 taken 21605 times.
✓ Branch 1 taken 92252 times.
113857 if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
336
2/2
✓ Branch 0 taken 21049 times.
✓ Branch 1 taken 556 times.
21605 if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
337
2/2
✓ Branch 0 taken 21398 times.
✓ Branch 1 taken 207 times.
21605 if (!frame->width) frame->width = avctx->width;
338
2/2
✓ Branch 0 taken 21398 times.
✓ Branch 1 taken 207 times.
21605 if (!frame->height) frame->height = avctx->height;
339
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 21603 times.
21605 if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
340 }
341 }
342 }
343 402583 emms_c();
344 402583 actual_got_frame = got_frame;
345
346
2/2
✓ Branch 0 taken 113967 times.
✓ Branch 1 taken 288616 times.
402583 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
347
2/2
✓ Branch 0 taken 179 times.
✓ Branch 1 taken 113788 times.
113967 if (frame->flags & AV_FRAME_FLAG_DISCARD)
348 179 got_frame = 0;
349
1/2
✓ Branch 0 taken 288616 times.
✗ Branch 1 not taken.
288616 } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
350 uint8_t *side;
351 size_t side_size;
352 288616 uint32_t discard_padding = 0;
353 288616 uint8_t skip_reason = 0;
354 288616 uint8_t discard_reason = 0;
355
356
4/4
✓ Branch 0 taken 288600 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 287174 times.
✓ Branch 3 taken 1426 times.
288616 if (ret >= 0 && got_frame) {
357
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287174 times.
287174 if (frame->format == AV_SAMPLE_FMT_NONE)
358 frame->format = avctx->sample_fmt;
359
2/2
✓ Branch 0 taken 1077 times.
✓ Branch 1 taken 286097 times.
287174 if (!frame->channel_layout)
360 1077 frame->channel_layout = avctx->channel_layout;
361
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287174 times.
287174 if (!frame->channels)
362 frame->channels = avctx->channels;
363
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 287172 times.
287174 if (!frame->sample_rate)
364 2 frame->sample_rate = avctx->sample_rate;
365 }
366
367 288616 side= av_packet_get_side_data(avci->last_pkt_props, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
368
3/4
✓ Branch 0 taken 107 times.
✓ Branch 1 taken 288509 times.
✓ Branch 2 taken 107 times.
✗ Branch 3 not taken.
288616 if(side && side_size>=10) {
369 107 avci->skip_samples = AV_RL32(side) * avci->skip_samples_multiplier;
370 107 discard_padding = AV_RL32(side + 4);
371 107 av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
372 avci->skip_samples, (int)discard_padding);
373 107 skip_reason = AV_RL8(side + 8);
374 107 discard_reason = AV_RL8(side + 9);
375 }
376
377
3/4
✓ Branch 0 taken 17 times.
✓ Branch 1 taken 288599 times.
✓ Branch 2 taken 17 times.
✗ Branch 3 not taken.
288616 if ((frame->flags & AV_FRAME_FLAG_DISCARD) && got_frame &&
378
1/2
✓ Branch 0 taken 17 times.
✗ Branch 1 not taken.
17 !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
379 17 avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples);
380 17 got_frame = 0;
381 17 *discarded_samples += frame->nb_samples;
382 }
383
384
4/4
✓ Branch 0 taken 169 times.
✓ Branch 1 taken 288447 times.
✓ Branch 2 taken 162 times.
✓ Branch 3 taken 7 times.
288616 if (avci->skip_samples > 0 && got_frame &&
385
1/2
✓ Branch 0 taken 162 times.
✗ Branch 1 not taken.
162 !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
386
2/2
✓ Branch 0 taken 109 times.
✓ Branch 1 taken 53 times.
162 if(frame->nb_samples <= avci->skip_samples){
387 109 got_frame = 0;
388 109 *discarded_samples += frame->nb_samples;
389 109 avci->skip_samples -= frame->nb_samples;
390 109 av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
391 avci->skip_samples);
392 } else {
393 53 av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
394 53 frame->nb_samples - avci->skip_samples, avctx->channels, frame->format);
395
2/4
✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 53 times.
✗ Branch 3 not taken.
106 if(avctx->pkt_timebase.num && avctx->sample_rate) {
396 53 int64_t diff_ts = av_rescale_q(avci->skip_samples,
397 53 (AVRational){1, avctx->sample_rate},
398 avctx->pkt_timebase);
399
1/2
✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
53 if(frame->pts!=AV_NOPTS_VALUE)
400 53 frame->pts += diff_ts;
401
1/2
✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
53 if(frame->pkt_dts!=AV_NOPTS_VALUE)
402 53 frame->pkt_dts += diff_ts;
403
1/2
✓ Branch 0 taken 53 times.
✗ Branch 1 not taken.
53 if (frame->pkt_duration >= diff_ts)
404 53 frame->pkt_duration -= diff_ts;
405 } else {
406 av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
407 }
408 53 av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
409 avci->skip_samples, frame->nb_samples);
410 53 *discarded_samples += avci->skip_samples;
411 53 frame->nb_samples -= avci->skip_samples;
412 53 avci->skip_samples = 0;
413 }
414 }
415
416
4/6
✓ Branch 0 taken 7 times.
✓ Branch 1 taken 288609 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7 times.
✗ Branch 5 not taken.
288616 if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
417
1/2
✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
7 !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
418
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5 times.
7 if (discard_padding == frame->nb_samples) {
419 2 *discarded_samples += frame->nb_samples;
420 2 got_frame = 0;
421 } else {
422
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) {
423 5 int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
424 5 (AVRational){1, avctx->sample_rate},
425 avctx->pkt_timebase);
426 5 frame->pkt_duration = diff_ts;
427 } else {
428 av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
429 }
430 5 av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
431 (int)discard_padding, frame->nb_samples);
432 5 frame->nb_samples -= discard_padding;
433 }
434 }
435
436
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 288616 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
288616 if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && got_frame) {
437 AVFrameSideData *fside = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10);
438 if (fside) {
439 AV_WL32(fside->data, avci->skip_samples);
440 AV_WL32(fside->data + 4, discard_padding);
441 AV_WL8(fside->data + 8, skip_reason);
442 AV_WL8(fside->data + 9, discard_reason);
443 avci->skip_samples = 0;
444 }
445 }
446 }
447
448
2/2
✓ Branch 0 taken 288616 times.
✓ Branch 1 taken 113967 times.
402583 if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
449
4/4
✓ Branch 0 taken 263293 times.
✓ Branch 1 taken 25323 times.
✓ Branch 2 taken 263279 times.
✓ Branch 3 taken 14 times.
288616 !avci->showed_multi_packet_warning &&
450
4/4
✓ Branch 0 taken 5265 times.
✓ Branch 1 taken 258014 times.
✓ Branch 2 taken 16 times.
✓ Branch 3 taken 5249 times.
263279 ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
451 16 av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
452 16 avci->showed_multi_packet_warning = 1;
453 }
454
455
2/2
✓ Branch 0 taken 9417 times.
✓ Branch 1 taken 393166 times.
402583 if (!got_frame)
456 9417 av_frame_unref(frame);
457
458 #if FF_API_FLAG_TRUNCATED
459
5/6
✓ Branch 0 taken 401594 times.
✓ Branch 1 taken 989 times.
✓ Branch 2 taken 112994 times.
✓ Branch 3 taken 288600 times.
✓ Branch 4 taken 112994 times.
✗ Branch 5 not taken.
402583 if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
460 #else
461 if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO)
462 #endif
463 112994 ret = pkt->size;
464
465 #if FF_API_AVCTX_TIMEBASE
466
3/4
✓ Branch 0 taken 83332 times.
✓ Branch 1 taken 319251 times.
✓ Branch 2 taken 83332 times.
✗ Branch 3 not taken.
402583 if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
467 83332 avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
468 #endif
469
470 /* do not stop draining when actual_got_frame != 0 or ret < 0 */
471 /* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
472
4/4
✓ Branch 0 taken 1410 times.
✓ Branch 1 taken 401173 times.
✓ Branch 2 taken 667 times.
✓ Branch 3 taken 743 times.
402583 if (avci->draining && !actual_got_frame) {
473
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 666 times.
667 if (ret < 0) {
474 /* prevent infinite loop if a decoder wrongly always return error on draining */
475 /* reasonable nb_errors_max = maximum b frames + thread count */
476
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 ?
477 avctx->thread_count : 1);
478
479
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
1 if (avci->nb_draining_errors++ >= nb_errors_max) {
480 av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
481 "Stop draining and force EOF.\n");
482 avci->draining_done = 1;
483 ret = AVERROR_BUG;
484 }
485 } else {
486 666 avci->draining_done = 1;
487 }
488 }
489
490
4/4
✓ Branch 0 taken 29658 times.
✓ Branch 1 taken 372925 times.
✓ Branch 2 taken 989 times.
✓ Branch 3 taken 28669 times.
402583 if (ret >= pkt->size || ret < 0) {
491 373914 av_packet_unref(pkt);
492 373914 av_packet_unref(avci->last_pkt_props);
493 } else {
494 28669 int consumed = ret;
495
496 28669 pkt->data += consumed;
497 28669 pkt->size -= consumed;
498 28669 pkt->pts = AV_NOPTS_VALUE;
499 28669 pkt->dts = AV_NOPTS_VALUE;
500
1/2
✓ Branch 0 taken 28669 times.
✗ Branch 1 not taken.
28669 if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) {
501 28669 avci->last_pkt_props->size -= consumed; // See extract_packet_props() comment.
502 28669 avci->last_pkt_props->pts = AV_NOPTS_VALUE;
503 28669 avci->last_pkt_props->dts = AV_NOPTS_VALUE;
504 }
505 }
506
507
2/2
✓ Branch 0 taken 393166 times.
✓ Branch 1 taken 9417 times.
402583 if (got_frame)
508
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 393166 times.
393166 av_assert0(frame->buf[0]);
509
510 402583 return ret < 0 ? ret : 0;
511 }
512
513 775083 static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
514 {
515 int ret;
516 775083 int64_t discarded_samples = 0;
517
518
2/2
✓ Branch 0 taken 783511 times.
✓ Branch 1 taken 393166 times.
1176677 while (!frame->buf[0]) {
519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 783511 times.
783511 if (discarded_samples > avctx->max_samples)
520 return AVERROR(EAGAIN);
521 783511 ret = decode_simple_internal(avctx, frame, &discarded_samples);
522
2/2
✓ Branch 0 taken 381917 times.
✓ Branch 1 taken 401594 times.
783511 if (ret < 0)
523 381917 return ret;
524 }
525
526 393166 return 0;
527 }
528
529 780278 static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
530 {
531 780278 AVCodecInternal *avci = avctx->internal;
532 int ret;
533
534
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 780278 times.
780278 av_assert0(!frame->buf[0]);
535
536
2/2
✓ Branch 0 taken 5195 times.
✓ Branch 1 taken 775083 times.
780278 if (avctx->codec->receive_frame) {
537 5195 ret = avctx->codec->receive_frame(avctx, frame);
538
2/2
✓ Branch 0 taken 2783 times.
✓ Branch 1 taken 2412 times.
5195 if (ret != AVERROR(EAGAIN))
539 2783 av_packet_unref(avci->last_pkt_props);
540 } else
541 775083 ret = decode_simple_receive_frame(avctx, frame);
542
543
2/2
✓ Branch 0 taken 11430 times.
✓ Branch 1 taken 768848 times.
780278 if (ret == AVERROR_EOF)
544 11430 avci->draining_done = 1;
545
546
1/2
✓ Branch 0 taken 780278 times.
✗ Branch 1 not taken.
780278 if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS) &&
547
3/4
✓ Branch 0 taken 751519 times.
✓ Branch 1 taken 28759 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 751519 times.
780278 IS_EMPTY(avci->last_pkt_props) && av_fifo_size(avci->pkt_props) >= sizeof(*avci->last_pkt_props))
548 av_fifo_generic_read(avci->pkt_props,
549 avci->last_pkt_props, sizeof(*avci->last_pkt_props), NULL);
550
551
2/2
✓ Branch 0 taken 395826 times.
✓ Branch 1 taken 384452 times.
780278 if (!ret) {
552 395826 frame->best_effort_timestamp = guess_correct_pts(avctx,
553 frame->pts,
554 frame->pkt_dts);
555
556 /* the only case where decode data is not set should be decoders
557 * that do not call ff_get_buffer() */
558
4/6
✓ Branch 0 taken 374430 times.
✓ Branch 1 taken 21396 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 374430 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 21396 times.
395826 av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
559 !(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
560
561
2/2
✓ Branch 0 taken 374430 times.
✓ Branch 1 taken 21396 times.
395826 if (frame->private_ref) {
562 374430 FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
563
564
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 374430 times.
374430 if (fdd->post_process) {
565 ret = fdd->post_process(avctx, frame);
566 if (ret < 0) {
567 av_frame_unref(frame);
568 return ret;
569 }
570 }
571 }
572 }
573
574 /* free the per-frame decode data */
575 780278 av_buffer_unref(&frame->private_ref);
576
577 780278 return ret;
578 }
579
580 381673 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
581 {
582 381673 AVCodecInternal *avci = avctx->internal;
583 int ret;
584
585
2/4
✓ Branch 1 taken 381673 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 381673 times.
381673 if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
586 return AVERROR(EINVAL);
587
588
2/2
✓ Branch 0 taken 680 times.
✓ Branch 1 taken 380993 times.
381673 if (avctx->internal->draining)
589 680 return AVERROR_EOF;
590
591
5/6
✓ Branch 0 taken 380977 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 5890 times.
✓ Branch 3 taken 375087 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5890 times.
380993 if (avpkt && !avpkt->size && avpkt->data)
592 return AVERROR(EINVAL);
593
594 380993 av_packet_unref(avci->buffer_pkt);
595
5/6
✓ Branch 0 taken 380977 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 5890 times.
✓ Branch 3 taken 375087 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 5890 times.
380993 if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
596 375087 ret = av_packet_ref(avci->buffer_pkt, avpkt);
597
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 375087 times.
375087 if (ret < 0)
598 return ret;
599 }
600
601 380993 ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
602
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 380993 times.
380993 if (ret < 0) {
603 av_packet_unref(avci->buffer_pkt);
604 return ret;
605 }
606
607
1/2
✓ Branch 0 taken 380993 times.
✗ Branch 1 not taken.
380993 if (!avci->buffer_frame->buf[0]) {
608 380993 ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
609
6/6
✓ Branch 0 taken 13047 times.
✓ Branch 1 taken 367946 times.
✓ Branch 2 taken 6522 times.
✓ Branch 3 taken 6525 times.
✓ Branch 4 taken 985 times.
✓ Branch 5 taken 5537 times.
380993 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
610 985 return ret;
611 }
612
613 380008 return 0;
614 }
615
616 108608 static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
617 {
618 /* make sure we are noisy about decoders returning invalid cropping data */
619
1/2
✓ Branch 0 taken 108608 times.
✗ Branch 1 not taken.
108608 if (frame->crop_left >= INT_MAX - frame->crop_right ||
620
1/2
✓ Branch 0 taken 108608 times.
✗ Branch 1 not taken.
108608 frame->crop_top >= INT_MAX - frame->crop_bottom ||
621
1/2
✓ Branch 0 taken 108608 times.
✗ Branch 1 not taken.
108608 (frame->crop_left + frame->crop_right) >= frame->width ||
622
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108608 times.
108608 (frame->crop_top + frame->crop_bottom) >= frame->height) {
623 av_log(avctx, AV_LOG_WARNING,
624 "Invalid cropping information set by a decoder: "
625 "%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER" "
626 "(frame size %dx%d). This is a bug, please report it\n",
627 frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
628 frame->width, frame->height);
629 frame->crop_left = 0;
630 frame->crop_right = 0;
631 frame->crop_top = 0;
632 frame->crop_bottom = 0;
633 return 0;
634 }
635
636
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108608 times.
108608 if (!avctx->apply_cropping)
637 return 0;
638
639 108608 return av_frame_apply_cropping(frame, avctx->flags & AV_CODEC_FLAG_UNALIGNED ?
640 AV_FRAME_CROP_UNALIGNED : 0);
641 }
642
643 767231 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
644 {
645 767231 AVCodecInternal *avci = avctx->internal;
646 int ret, changed;
647
648 767231 av_frame_unref(frame);
649
650
2/4
✓ Branch 1 taken 767231 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 767231 times.
767231 if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
651 return AVERROR(EINVAL);
652
653
2/2
✓ Branch 0 taken 367946 times.
✓ Branch 1 taken 399285 times.
767231 if (avci->buffer_frame->buf[0]) {
654 367946 av_frame_move_ref(frame, avci->buffer_frame);
655 } else {
656 399285 ret = decode_receive_frame_internal(avctx, frame);
657
2/2
✓ Branch 0 taken 371405 times.
✓ Branch 1 taken 27880 times.
399285 if (ret < 0)
658 371405 return ret;
659 }
660
661
2/2
✓ Branch 0 taken 108608 times.
✓ Branch 1 taken 287218 times.
395826 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
662 108608 ret = apply_cropping(avctx, frame);
663
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108608 times.
108608 if (ret < 0) {
664 av_frame_unref(frame);
665 return ret;
666 }
667 }
668
669 395826 avctx->frame_number++;
670
671
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 395826 times.
395826 if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
672
673 if (avctx->frame_number == 1) {
674 avci->initial_format = frame->format;
675 switch(avctx->codec_type) {
676 case AVMEDIA_TYPE_VIDEO:
677 avci->initial_width = frame->width;
678 avci->initial_height = frame->height;
679 break;
680 case AVMEDIA_TYPE_AUDIO:
681 avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
682 avctx->sample_rate;
683 avci->initial_channels = frame->channels;
684 avci->initial_channel_layout = frame->channel_layout;
685 break;
686 }
687 }
688
689 if (avctx->frame_number > 1) {
690 changed = avci->initial_format != frame->format;
691
692 switch(avctx->codec_type) {
693 case AVMEDIA_TYPE_VIDEO:
694 changed |= avci->initial_width != frame->width ||
695 avci->initial_height != frame->height;
696 break;
697 case AVMEDIA_TYPE_AUDIO:
698 changed |= avci->initial_sample_rate != frame->sample_rate ||
699 avci->initial_sample_rate != avctx->sample_rate ||
700 avci->initial_channels != frame->channels ||
701 avci->initial_channel_layout != frame->channel_layout;
702 break;
703 }
704
705 if (changed) {
706 avci->changed_frames_dropped++;
707 av_log(avctx, AV_LOG_INFO, "dropped changed frame #%d pts %"PRId64
708 " drop count: %d \n",
709 avctx->frame_number, frame->pts,
710 avci->changed_frames_dropped);
711 av_frame_unref(frame);
712 return AVERROR_INPUT_CHANGED;
713 }
714 }
715 }
716 395826 return 0;
717 }
718
719 1387 static void get_subtitle_defaults(AVSubtitle *sub)
720 {
721 1387 memset(sub, 0, sizeof(*sub));
722 1387 sub->pts = AV_NOPTS_VALUE;
723 1387 }
724
725 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
726 1354 static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt,
727 AVPacket *inpkt, AVPacket *buf_pkt)
728 {
729 #if CONFIG_ICONV
730 1354 iconv_t cd = (iconv_t)-1;
731 1354 int ret = 0;
732 char *inb, *outb;
733 size_t inl, outl;
734 #endif
735
736
3/4
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 1261 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
1354 if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
737 1261 *outpkt = inpkt;
738 1261 return 0;
739 }
740
741 #if CONFIG_ICONV
742 93 inb = inpkt->data;
743 93 inl = inpkt->size;
744
745
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
93 if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
746 av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
747 return AVERROR(ERANGE);
748 }
749
750 93 cd = iconv_open("UTF-8", avctx->sub_charenc);
751
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
93 av_assert0(cd != (iconv_t)-1);
752
753 93 ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
754
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
93 if (ret < 0)
755 goto end;
756 93 ret = av_packet_copy_props(buf_pkt, inpkt);
757
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
93 if (ret < 0)
758 goto end;
759 93 outb = buf_pkt->data;
760 93 outl = buf_pkt->size;
761
762
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 ||
763 93 iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
764
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) {
765 ret = FFMIN(AVERROR(errno), -1);
766 av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
767 "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
768 goto end;
769 }
770 93 buf_pkt->size -= outl;
771 93 memset(buf_pkt->data + buf_pkt->size, 0, outl);
772 93 *outpkt = buf_pkt;
773
774 93 ret = 0;
775 93 end:
776
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
93 if (ret < 0)
777 av_packet_unref(buf_pkt);
778
1/2
✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
93 if (cd != (iconv_t)-1)
779 93 iconv_close(cd);
780 93 return ret;
781 #else
782 av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
783 return AVERROR(EINVAL);
784 #endif
785 }
786
787 641 static int utf8_check(const uint8_t *str)
788 {
789 const uint8_t *byte;
790 uint32_t codepoint, min;
791
792
2/2
✓ Branch 0 taken 57437 times.
✓ Branch 1 taken 641 times.
58078 while (*str) {
793 57437 byte = str;
794
5/8
✓ Branch 0 taken 57437 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 57437 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2794 times.
✓ Branch 6 taken 2794 times.
✓ Branch 7 taken 57437 times.
60231 GET_UTF8(codepoint, *(byte++), return 0;);
795
4/4
✓ Branch 0 taken 2089 times.
✓ Branch 1 taken 55348 times.
✓ Branch 2 taken 705 times.
✓ Branch 3 taken 1384 times.
58142 min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
796 705 1 << (5 * (byte - str) - 4);
797
3/6
✓ Branch 0 taken 57437 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 57437 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 57437 times.
✗ Branch 5 not taken.
57437 if (codepoint < min || codepoint >= 0x110000 ||
798
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 57437 times.
57437 codepoint == 0xFFFE /* BOM */ ||
799 codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
800 return 0;
801 57437 str = byte;
802 }
803 641 return 1;
804 }
805
806 1387 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
807 int *got_sub_ptr,
808 AVPacket *avpkt)
809 {
810 1387 int ret = 0;
811
812
3/4
✓ Branch 0 taken 37 times.
✓ Branch 1 taken 1350 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 37 times.
1387 if (!avpkt->data && avpkt->size) {
813 av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
814 return AVERROR(EINVAL);
815 }
816
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1387 times.
1387 if (!avctx->codec)
817 return AVERROR(EINVAL);
818
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1387 times.
1387 if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
819 av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
820 return AVERROR(EINVAL);
821 }
822
823 1387 *got_sub_ptr = 0;
824 1387 get_subtitle_defaults(sub);
825
826
4/4
✓ Branch 0 taken 807 times.
✓ Branch 1 taken 580 times.
✓ Branch 2 taken 774 times.
✓ Branch 3 taken 33 times.
1387 if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
827 1354 AVCodecInternal *avci = avctx->internal;
828 AVPacket *pkt;
829
830 1354 ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt);
831
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1354 times.
1354 if (ret < 0)
832 return ret;
833
834
3/4
✓ Branch 0 taken 1354 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1348 times.
✓ Branch 3 taken 6 times.
1354 if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
835 1348 sub->pts = av_rescale_q(avpkt->pts,
836 1348 avctx->pkt_timebase, AV_TIME_BASE_Q);
837 1354 ret = avctx->codec->decode(avctx, sub, got_sub_ptr, pkt);
838 av_assert1((ret >= 0) >= !!*got_sub_ptr &&
839 !!*got_sub_ptr >= !!sub->num_rects);
840
841
6/6
✓ Branch 0 taken 765 times.
✓ Branch 1 taken 589 times.
✓ Branch 2 taken 537 times.
✓ Branch 3 taken 228 times.
✓ Branch 4 taken 485 times.
✓ Branch 5 taken 52 times.
1354 if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
842
1/2
✓ Branch 0 taken 485 times.
✗ Branch 1 not taken.
485 avctx->pkt_timebase.num) {
843 485 AVRational ms = { 1, 1000 };
844 485 sub->end_display_time = av_rescale_q(avpkt->duration,
845 avctx->pkt_timebase, ms);
846 }
847
848
2/2
✓ Branch 0 taken 150 times.
✓ Branch 1 taken 1204 times.
1354 if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB)
849 150 sub->format = 0;
850
1/2
✓ Branch 0 taken 1204 times.
✗ Branch 1 not taken.
1204 else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
851 1204 sub->format = 1;
852
853
2/2
✓ Branch 0 taken 796 times.
✓ Branch 1 taken 1354 times.
2150 for (unsigned i = 0; i < sub->num_rects; i++) {
854
1/2
✓ Branch 0 taken 796 times.
✗ Branch 1 not taken.
796 if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_IGNORE &&
855
3/4
✓ Branch 0 taken 641 times.
✓ Branch 1 taken 155 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 641 times.
796 sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
856 av_log(avctx, AV_LOG_ERROR,
857 "Invalid UTF-8 in decoded subtitles text; "
858 "maybe missing -sub_charenc option\n");
859 avsubtitle_free(sub);
860 ret = AVERROR_INVALIDDATA;
861 break;
862 }
863 }
864
865
2/2
✓ Branch 0 taken 774 times.
✓ Branch 1 taken 580 times.
1354 if (*got_sub_ptr)
866 774 avctx->frame_number++;
867
868
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 1261 times.
1354 if (pkt == avci->buffer_pkt) // did we recode?
869 93 av_packet_unref(avci->buffer_pkt);
870 }
871
872 1387 return ret;
873 }
874
875 1425 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx,
876 const enum AVPixelFormat *fmt)
877 {
878 const AVPixFmtDescriptor *desc;
879 const AVCodecHWConfig *config;
880 int i, n;
881
882 // If a device was supplied when the codec was opened, assume that the
883 // user wants to use it.
884
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1425 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
1425 if (avctx->hw_device_ctx && avctx->codec->hw_configs) {
885 AVHWDeviceContext *device_ctx =
886 (AVHWDeviceContext*)avctx->hw_device_ctx->data;
887 for (i = 0;; i++) {
888 config = &avctx->codec->hw_configs[i]->public;
889 if (!config)
890 break;
891 if (!(config->methods &
892 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
893 continue;
894 if (device_ctx->type != config->device_type)
895 continue;
896 for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
897 if (config->pix_fmt == fmt[n])
898 return fmt[n];
899 }
900 }
901 }
902 // No device or other setup, so we have to choose from things which
903 // don't any other external information.
904
905 // If the last element of the list is a software format, choose it
906 // (this should be best software format if any exist).
907
2/2
✓ Branch 0 taken 3645 times.
✓ Branch 1 taken 1425 times.
5070 for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
908 1425 desc = av_pix_fmt_desc_get(fmt[n - 1]);
909
1/2
✓ Branch 0 taken 1425 times.
✗ Branch 1 not taken.
1425 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
910 1425 return fmt[n - 1];
911
912 // Finally, traverse the list in order and choose the first entry
913 // with no external dependencies (if there is no hardware configuration
914 // information available then this just picks the first entry).
915 for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
916 for (i = 0;; i++) {
917 config = avcodec_get_hw_config(avctx->codec, i);
918 if (!config)
919 break;
920 if (config->pix_fmt == fmt[n])
921 break;
922 }
923 if (!config) {
924 // No specific config available, so the decoder must be able
925 // to handle this format without any additional setup.
926 return fmt[n];
927 }
928 if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
929 // Usable with only internal setup.
930 return fmt[n];
931 }
932 }
933
934 // Nothing is usable, give up.
935 return AV_PIX_FMT_NONE;
936 }
937
938 int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx,
939 enum AVHWDeviceType dev_type)
940 {
941 AVHWDeviceContext *device_ctx;
942 AVHWFramesContext *frames_ctx;
943 int ret;
944
945 if (!avctx->hwaccel)
946 return AVERROR(ENOSYS);
947
948 if (avctx->hw_frames_ctx)
949 return 0;
950 if (!avctx->hw_device_ctx) {
951 av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
952 "required for hardware accelerated decoding.\n");
953 return AVERROR(EINVAL);
954 }
955
956 device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
957 if (device_ctx->type != dev_type) {
958 av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
959 "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
960 av_hwdevice_get_type_name(device_ctx->type));
961 return AVERROR(EINVAL);
962 }
963
964 ret = avcodec_get_hw_frames_parameters(avctx,
965 avctx->hw_device_ctx,
966 avctx->hwaccel->pix_fmt,
967 &avctx->hw_frames_ctx);
968 if (ret < 0)
969 return ret;
970
971 frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
972
973
974 if (frames_ctx->initial_pool_size) {
975 // We guarantee 4 base work surfaces. The function above guarantees 1
976 // (the absolute minimum), so add the missing count.
977 frames_ctx->initial_pool_size += 3;
978 }
979
980 ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
981 if (ret < 0) {
982 av_buffer_unref(&avctx->hw_frames_ctx);
983 return ret;
984 }
985
986 return 0;
987 }
988
989 int avcodec_get_hw_frames_parameters(AVCodecContext *avctx,
990 AVBufferRef *device_ref,
991 enum AVPixelFormat hw_pix_fmt,
992 AVBufferRef **out_frames_ref)
993 {
994 AVBufferRef *frames_ref = NULL;
995 const AVCodecHWConfigInternal *hw_config;
996 const AVHWAccel *hwa;
997 int i, ret;
998
999 for (i = 0;; i++) {
1000 hw_config = avctx->codec->hw_configs[i];
1001 if (!hw_config)
1002 return AVERROR(ENOENT);
1003 if (hw_config->public.pix_fmt == hw_pix_fmt)
1004 break;
1005 }
1006
1007 hwa = hw_config->hwaccel;
1008 if (!hwa || !hwa->frame_params)
1009 return AVERROR(ENOENT);
1010
1011 frames_ref = av_hwframe_ctx_alloc(device_ref);
1012 if (!frames_ref)
1013 return AVERROR(ENOMEM);
1014
1015 ret = hwa->frame_params(avctx, frames_ref);
1016 if (ret >= 0) {
1017 AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1018
1019 if (frames_ctx->initial_pool_size) {
1020 // If the user has requested that extra output surfaces be
1021 // available then add them here.
1022 if (avctx->extra_hw_frames > 0)
1023 frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1024
1025 // If frame threading is enabled then an extra surface per thread
1026 // is also required.
1027 if (avctx->active_thread_type & FF_THREAD_FRAME)
1028 frames_ctx->initial_pool_size += avctx->thread_count;
1029 }
1030
1031 *out_frames_ref = frames_ref;
1032 } else {
1033 av_buffer_unref(&frames_ref);
1034 }
1035 return ret;
1036 }
1037
1038 static int hwaccel_init(AVCodecContext *avctx,
1039 const AVCodecHWConfigInternal *hw_config)
1040 {
1041 const AVHWAccel *hwaccel;
1042 int err;
1043
1044 hwaccel = hw_config->hwaccel;
1045 if (hwaccel->capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1046 avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1047 av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1048 hwaccel->name);
1049 return AVERROR_PATCHWELCOME;
1050 }
1051
1052 if (hwaccel->priv_data_size) {
1053 avctx->internal->hwaccel_priv_data =
1054 av_mallocz(hwaccel->priv_data_size);
1055 if (!avctx->internal->hwaccel_priv_data)
1056 return AVERROR(ENOMEM);
1057 }
1058
1059 avctx->hwaccel = hwaccel;
1060 if (hwaccel->init) {
1061 err = hwaccel->init(avctx);
1062 if (err < 0) {
1063 av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1064 "hwaccel initialisation returned error.\n",
1065 av_get_pix_fmt_name(hw_config->public.pix_fmt));
1066 av_freep(&avctx->internal->hwaccel_priv_data);
1067 avctx->hwaccel = NULL;
1068 return err;
1069 }
1070 }
1071
1072 return 0;
1073 }
1074
1075 2358 static void hwaccel_uninit(AVCodecContext *avctx)
1076 {
1077
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2358 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
2358 if (avctx->hwaccel && avctx->hwaccel->uninit)
1078 avctx->hwaccel->uninit(avctx);
1079
1080 2358 av_freep(&avctx->internal->hwaccel_priv_data);
1081
1082 2358 avctx->hwaccel = NULL;
1083
1084 2358 av_buffer_unref(&avctx->hw_frames_ctx);
1085 2358 }
1086
1087 2358 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1088 {
1089 const AVPixFmtDescriptor *desc;
1090 enum AVPixelFormat *choices;
1091 enum AVPixelFormat ret, user_choice;
1092 const AVCodecHWConfigInternal *hw_config;
1093 const AVCodecHWConfig *config;
1094 int i, n, err;
1095
1096 // Find end of list.
1097
2/2
✓ Branch 0 taken 6201 times.
✓ Branch 1 taken 2358 times.
8559 for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1098 // Must contain at least one entry.
1099
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2358 times.
2358 av_assert0(n >= 1);
1100 // If a software format is available, it must be the last entry.
1101 2358 desc = av_pix_fmt_desc_get(fmt[n - 1]);
1102
1/2
✓ Branch 0 taken 2358 times.
✗ Branch 1 not taken.
2358 if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1103 // No software format is available.
1104 } else {
1105 2358 avctx->sw_pix_fmt = fmt[n - 1];
1106 }
1107
1108 2358 choices = av_malloc_array(n + 1, sizeof(*choices));
1109
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2358 times.
2358 if (!choices)
1110 return AV_PIX_FMT_NONE;
1111
1112 2358 memcpy(choices, fmt, (n + 1) * sizeof(*choices));
1113
1114 for (;;) {
1115 // Remove the previous hwaccel, if there was one.
1116 2358 hwaccel_uninit(avctx);
1117
1118 2358 user_choice = avctx->get_format(avctx, choices);
1119
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2358 times.
2358 if (user_choice == AV_PIX_FMT_NONE) {
1120 // Explicitly chose nothing, give up.
1121 ret = AV_PIX_FMT_NONE;
1122 break;
1123 }
1124
1125 2358 desc = av_pix_fmt_desc_get(user_choice);
1126
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2358 times.
2358 if (!desc) {
1127 av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1128 "get_format() callback.\n");
1129 ret = AV_PIX_FMT_NONE;
1130 break;
1131 }
1132 2358 av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1133 2358 desc->name);
1134
1135
1/2
✓ Branch 0 taken 6201 times.
✗ Branch 1 not taken.
6201 for (i = 0; i < n; i++) {
1136
2/2
✓ Branch 0 taken 2358 times.
✓ Branch 1 taken 3843 times.
6201 if (choices[i] == user_choice)
1137 2358 break;
1138 }
1139
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2358 times.
2358 if (i == n) {
1140 av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1141 "%s not in possible list.\n", desc->name);
1142 ret = AV_PIX_FMT_NONE;
1143 break;
1144 }
1145
1146
2/2
✓ Branch 0 taken 2237 times.
✓ Branch 1 taken 121 times.
2358 if (avctx->codec->hw_configs) {
1147 6293 for (i = 0;; i++) {
1148 6293 hw_config = avctx->codec->hw_configs[i];
1149
2/2
✓ Branch 0 taken 2237 times.
✓ Branch 1 taken 4056 times.
6293 if (!hw_config)
1150 2237 break;
1151
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4056 times.
4056 if (hw_config->public.pix_fmt == user_choice)
1152 break;
1153 }
1154 } else {
1155 121 hw_config = NULL;
1156 }
1157
1158
1/2
✓ Branch 0 taken 2358 times.
✗ Branch 1 not taken.
2358 if (!hw_config) {
1159 // No config available, so no extra setup required.
1160 2358 ret = user_choice;
1161 2358 break;
1162 }
1163 config = &hw_config->public;
1164
1165 if (config->methods &
1166 AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
1167 avctx->hw_frames_ctx) {
1168 const AVHWFramesContext *frames_ctx =
1169 (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1170 if (frames_ctx->format != user_choice) {
1171 av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1172 "does not match the format of the provided frames "
1173 "context.\n", desc->name);
1174 goto try_again;
1175 }
1176 } else if (config->methods &
1177 AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
1178 avctx->hw_device_ctx) {
1179 const AVHWDeviceContext *device_ctx =
1180 (AVHWDeviceContext*)avctx->hw_device_ctx->data;
1181 if (device_ctx->type != config->device_type) {
1182 av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1183 "does not match the type of the provided device "
1184 "context.\n", desc->name);
1185 goto try_again;
1186 }
1187 } else if (config->methods &
1188 AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1189 // Internal-only setup, no additional configuration.
1190 } else if (config->methods &
1191 AV_CODEC_HW_CONFIG_METHOD_AD_HOC) {
1192 // Some ad-hoc configuration we can't see and can't check.
1193 } else {
1194 av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1195 "missing configuration.\n", desc->name);
1196 goto try_again;
1197 }
1198 if (hw_config->hwaccel) {
1199 av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1200 "initialisation.\n", desc->name);
1201 err = hwaccel_init(avctx, hw_config);
1202 if (err < 0)
1203 goto try_again;
1204 }
1205 ret = user_choice;
1206 break;
1207
1208 try_again:
1209 av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1210 "get_format() without it.\n", desc->name);
1211 for (i = 0; i < n; i++) {
1212 if (choices[i] == user_choice)
1213 break;
1214 }
1215 for (; i + 1 < n; i++)
1216 choices[i] = choices[i + 1];
1217 --n;
1218 }
1219
1220 2358 av_freep(&choices);
1221 2358 return ret;
1222 }
1223
1224 16643 static void frame_pool_free(void *opaque, uint8_t *data)
1225 {
1226 16643 FramePool *pool = (FramePool*)data;
1227 int i;
1228
1229
2/2
✓ Branch 0 taken 66572 times.
✓ Branch 1 taken 16643 times.
83215 for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1230 66572 av_buffer_pool_uninit(&pool->pools[i]);
1231
1232 16643 av_freep(&data);
1233 16643 }
1234
1235 16643 static AVBufferRef *frame_pool_alloc(void)
1236 {
1237 16643 FramePool *pool = av_mallocz(sizeof(*pool));
1238 AVBufferRef *buf;
1239
1240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16643 times.
16643 if (!pool)
1241 return NULL;
1242
1243 16643 buf = av_buffer_create((uint8_t*)pool, sizeof(*pool),
1244 frame_pool_free, NULL, 0);
1245
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16643 times.
16643 if (!buf) {
1246 av_freep(&pool);
1247 return NULL;
1248 }
1249
1250 16643 return buf;
1251 }
1252
1253 379986 static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
1254 {
1255 759972 FramePool *pool = avctx->internal->pool ?
1256
2/2
✓ Branch 0 taken 370157 times.
✓ Branch 1 taken 9829 times.
379986 (FramePool*)avctx->internal->pool->data : NULL;
1257 AVBufferRef *pool_buf;
1258 int i, ret, ch, planes;
1259
1260
2/2
✓ Branch 0 taken 287442 times.
✓ Branch 1 taken 92544 times.
379986 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1261 287442 int planar = av_sample_fmt_is_planar(frame->format);
1262 287442 ch = frame->channels;
1263
2/2
✓ Branch 0 taken 151608 times.
✓ Branch 1 taken 135834 times.
287442 planes = planar ? ch : 1;
1264 }
1265
1266
4/4
✓ Branch 0 taken 370157 times.
✓ Branch 1 taken 9829 times.
✓ Branch 2 taken 369982 times.
✓ Branch 3 taken 175 times.
379986 if (pool && pool->format == frame->format) {
1267
2/2
✓ Branch 0 taken 84270 times.
✓ Branch 1 taken 285712 times.
369982 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1268
4/4
✓ Branch 0 taken 84030 times.
✓ Branch 1 taken 240 times.
✓ Branch 2 taken 84019 times.
✓ Branch 3 taken 11 times.
84270 pool->width == frame->width && pool->height == frame->height)
1269 84019 return 0;
1270
4/4
✓ Branch 0 taken 285712 times.
✓ Branch 1 taken 251 times.
✓ Branch 2 taken 285699 times.
✓ Branch 3 taken 13 times.
285963 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pool->planes == planes &&
1271
3/4
✓ Branch 0 taken 285699 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 279324 times.
✓ Branch 3 taken 6375 times.
285699 pool->channels == ch && frame->nb_samples == pool->samples)
1272 279324 return 0;
1273 }
1274
1275 16643 pool_buf = frame_pool_alloc();
1276
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 16643 times.
16643 if (!pool_buf)
1277 return AVERROR(ENOMEM);
1278 16643 pool = (FramePool*)pool_buf->data;
1279
1280
2/3
✓ Branch 0 taken 8525 times.
✓ Branch 1 taken 8118 times.
✗ Branch 2 not taken.
16643 switch (avctx->codec_type) {
1281 8525 case AVMEDIA_TYPE_VIDEO: {
1282 int linesize[4];
1283 8525 int w = frame->width;
1284 8525 int h = frame->height;
1285 int unaligned;
1286 ptrdiff_t linesize1[4];
1287 size_t size[4];
1288
1289 8525 avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
1290
1291 do {
1292 // NOTE: do not align linesizes individually, this breaks e.g. assumptions
1293 // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
1294 17146 ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
1295
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 17146 times.
17146 if (ret < 0)
1296 goto fail;
1297 // increase alignment of w for next try (rhs gives the lowest bit set in w)
1298 17146 w += w & ~(w - 1);
1299
1300 17146 unaligned = 0;
1301
2/2
✓ Branch 0 taken 68584 times.
✓ Branch 1 taken 17146 times.
85730 for (i = 0; i < 4; i++)
1302 68584 unaligned |= linesize[i] % pool->stride_align[i];
1303
2/2
✓ Branch 0 taken 8621 times.
✓ Branch 1 taken 8525 times.
17146 } while (unaligned);
1304
1305
2/2
✓ Branch 0 taken 34100 times.
✓ Branch 1 taken 8525 times.
42625 for (i = 0; i < 4; i++)
1306 34100 linesize1[i] = linesize[i];
1307 8525 ret = av_image_fill_plane_sizes(size, avctx->pix_fmt, h, linesize1);
1308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8525 times.
8525 if (ret < 0)
1309 goto fail;
1310
1311
2/2
✓ Branch 0 taken 34100 times.
✓ Branch 1 taken 8525 times.
42625 for (i = 0; i < 4; i++) {
1312 34100 pool->linesize[i] = linesize[i];
1313
2/2
✓ Branch 0 taken 24118 times.
✓ Branch 1 taken 9982 times.
34100 if (size[i]) {
1314
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24118 times.
24118 if (size[i] > INT_MAX - (16 + STRIDE_ALIGN - 1)) {
1315 ret = AVERROR(EINVAL);
1316 goto fail;
1317 }
1318 24118 pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
1319 CONFIG_MEMORY_POISONING ?
1320 NULL :
1321 av_buffer_allocz);
1322
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 24118 times.
24118 if (!pool->pools[i]) {
1323 ret = AVERROR(ENOMEM);
1324 goto fail;
1325 }
1326 }
1327 }
1328 8525 pool->format = frame->format;
1329 8525 pool->width = frame->width;
1330 8525 pool->height = frame->height;
1331
1332 8525 break;
1333 }
1334 8118 case AVMEDIA_TYPE_AUDIO: {
1335 8118 ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
1336 8118 frame->nb_samples, frame->format, 0);
1337
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8118 times.
8118 if (ret < 0)
1338 goto fail;
1339
1340 8118 pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
1341
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8118 times.
8118 if (!pool->pools[0]) {
1342 ret = AVERROR(ENOMEM);
1343 goto fail;
1344 }
1345
1346 8118 pool->format = frame->format;
1347 8118 pool->planes = planes;
1348 8118 pool->channels = ch;
1349 8118 pool->samples = frame->nb_samples;
1350 8118 break;
1351 }
1352 default: av_assert0(0);
1353 }
1354
1355 16643 av_buffer_unref(&avctx->internal->pool);
1356 16643 avctx->internal->pool = pool_buf;
1357
1358 16643 return 0;
1359 fail:
1360 av_buffer_unref(&pool_buf);
1361 return ret;
1362 }
1363
1364 287442 static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
1365 {
1366 287442 FramePool *pool = (FramePool*)avctx->internal->pool->data;
1367 287442 int planes = pool->planes;
1368 int i;
1369
1370 287442 frame->linesize[0] = pool->linesize[0];
1371
1372
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287442 times.
287442 if (planes > AV_NUM_DATA_POINTERS) {
1373 frame->extended_data = av_calloc(planes, sizeof(*frame->extended_data));
1374 frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
1375 frame->extended_buf = av_calloc(frame->nb_extended_buf,
1376 sizeof(*frame->extended_buf));
1377 if (!frame->extended_data || !frame->extended_buf) {
1378 av_freep(&frame->extended_data);
1379 av_freep(&frame->extended_buf);
1380 return AVERROR(ENOMEM);
1381 }
1382 } else {
1383 287442 frame->extended_data = frame->data;
1384
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287442 times.
287442 av_assert0(frame->nb_extended_buf == 0);
1385 }
1386
1387
2/2
✓ Branch 0 taken 429783 times.
✓ Branch 1 taken 287442 times.
717225 for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
1388 429783 frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
1389
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 429783 times.
429783 if (!frame->buf[i])
1390 goto fail;
1391 429783 frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
1392 }
1393
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287442 times.
287442 for (i = 0; i < frame->nb_extended_buf; i++) {
1394 frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
1395 if (!frame->extended_buf[i])
1396 goto fail;
1397 frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
1398 }
1399
1400
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287442 times.
287442 if (avctx->debug & FF_DEBUG_BUFFERS)
1401 av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
1402
1403 287442 return 0;
1404 fail:
1405 av_frame_unref(frame);
1406 return AVERROR(ENOMEM);
1407 }
1408
1409 92544 static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
1410 {
1411 92544 FramePool *pool = (FramePool*)s->internal->pool->data;
1412 92544 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
1413 int i;
1414
1415
4/8
✓ Branch 0 taken 92544 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 92544 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 92544 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 92544 times.
92544 if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
1416 av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
1417 return -1;
1418 }
1419
1420
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 92544 times.
92544 if (!desc) {
1421 av_log(s, AV_LOG_ERROR,
1422 "Unable to get pixel format descriptor for format %s\n",
1423 av_get_pix_fmt_name(pic->format));
1424 return AVERROR(EINVAL);
1425 }
1426
1427 92544 memset(pic->data, 0, sizeof(pic->data));
1428 92544 pic->extended_data = pic->data;
1429
1430
4/4
✓ Branch 0 taken 356614 times.
✓ Branch 1 taken 657 times.
✓ Branch 2 taken 264727 times.
✓ Branch 3 taken 91887 times.
357271 for (i = 0; i < 4 && pool->pools[i]; i++) {
1431 264727 pic->linesize[i] = pool->linesize[i];
1432
1433 264727 pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
1434
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 264727 times.
264727 if (!pic->buf[i])
1435 goto fail;
1436
1437 264727 pic->data[i] = pic->buf[i]->data;
1438 }
1439
2/2
✓ Branch 0 taken 475625 times.
✓ Branch 1 taken 92544 times.
568169 for (; i < AV_NUM_DATA_POINTERS; i++) {
1440 475625 pic->data[i] = NULL;
1441 475625 pic->linesize[i] = 0;
1442 }
1443
1444
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 92544 times.
92544 if (s->debug & FF_DEBUG_BUFFERS)
1445 av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
1446
1447 92544 return 0;
1448 fail:
1449 av_frame_unref(pic);
1450 return AVERROR(ENOMEM);
1451 }
1452
1453 379986 int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
1454 {
1455 int ret;
1456
1457
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379986 times.
379986 if (avctx->hw_frames_ctx) {
1458 ret = av_hwframe_get_buffer(avctx->hw_frames_ctx, frame, 0);
1459 frame->width = avctx->coded_width;
1460 frame->height = avctx->coded_height;
1461 return ret;
1462 }
1463
1464
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 379986 times.
379986 if ((ret = update_frame_pool(avctx, frame)) < 0)
1465 return ret;
1466
1467
2/3
✓ Branch 0 taken 92544 times.
✓ Branch 1 taken 287442 times.
✗ Branch 2 not taken.
379986 switch (avctx->codec_type) {
1468 92544 case AVMEDIA_TYPE_VIDEO:
1469 92544 return video_get_buffer(avctx, frame);
1470 287442 case AVMEDIA_TYPE_AUDIO:
1471 287442 return audio_get_buffer(avctx, frame);
1472 default:
1473 return -1;
1474 }
1475 }
1476
1477 406713 static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
1478 {
1479 size_t size;
1480 const uint8_t *side_metadata;
1481
1482 406713 AVDictionary **frame_md = &frame->metadata;
1483
1484 406713 side_metadata = av_packet_get_side_data(avpkt,
1485 AV_PKT_DATA_STRINGS_METADATA, &size);
1486 406713 return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1487 }
1488
1489 406713 int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
1490 {
1491 406713 AVPacket *pkt = avctx->internal->last_pkt_props;
1492 static const struct {
1493 enum AVPacketSideDataType packet;
1494 enum AVFrameSideDataType frame;
1495 } sd[] = {
1496 { AV_PKT_DATA_REPLAYGAIN , AV_FRAME_DATA_REPLAYGAIN },
1497 { AV_PKT_DATA_DISPLAYMATRIX, AV_FRAME_DATA_DISPLAYMATRIX },
1498 { AV_PKT_DATA_SPHERICAL, AV_FRAME_DATA_SPHERICAL },
1499 { AV_PKT_DATA_STEREO3D, AV_FRAME_DATA_STEREO3D },
1500 { AV_PKT_DATA_AUDIO_SERVICE_TYPE, AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
1501 { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA },
1502 { AV_PKT_DATA_CONTENT_LIGHT_LEVEL, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL },
1503 { AV_PKT_DATA_A53_CC, AV_FRAME_DATA_A53_CC },
1504 { AV_PKT_DATA_ICC_PROFILE, AV_FRAME_DATA_ICC_PROFILE },
1505 { AV_PKT_DATA_S12M_TIMECODE, AV_FRAME_DATA_S12M_TIMECODE },
1506 { AV_PKT_DATA_DYNAMIC_HDR10_PLUS, AV_FRAME_DATA_DYNAMIC_HDR_PLUS },
1507 };
1508
1509
1/2
✓ Branch 0 taken 406713 times.
✗ Branch 1 not taken.
406713 if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) {
1510 406713 frame->pts = pkt->pts;
1511 406713 frame->pkt_pos = pkt->pos;
1512 406713 frame->pkt_duration = pkt->duration;
1513 406713 frame->pkt_size = pkt->size;
1514
1515
2/2
✓ Branch 0 taken 4473843 times.
✓ Branch 1 taken 406713 times.
4880556 for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1516 size_t size;
1517 4473843 uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1518
2/2
✓ Branch 0 taken 211 times.
✓ Branch 1 taken 4473632 times.
4473843 if (packet_sd) {
1519 211 AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
1520 211 sd[i].frame,
1521 size);
1522
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 211 times.
211 if (!frame_sd)
1523 return AVERROR(ENOMEM);
1524
1525 211 memcpy(frame_sd->data, packet_sd, size);
1526 }
1527 }
1528 406713 add_metadata_from_side_data(pkt, frame);
1529
1530
2/2
✓ Branch 0 taken 199 times.
✓ Branch 1 taken 406514 times.
406713 if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1531 199 frame->flags |= AV_FRAME_FLAG_DISCARD;
1532 } else {
1533 406514 frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1534 }
1535 }
1536 406713 frame->reordered_opaque = avctx->reordered_opaque;
1537
1538
1/2
✓ Branch 0 taken 406713 times.
✗ Branch 1 not taken.
406713 if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
1539 406713 frame->color_primaries = avctx->color_primaries;
1540
1/2
✓ Branch 0 taken 406713 times.
✗ Branch 1 not taken.
406713 if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
1541 406713 frame->color_trc = avctx->color_trc;
1542
2/2
✓ Branch 0 taken 406278 times.
✓ Branch 1 taken 435 times.
406713 if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
1543 406278 frame->colorspace = avctx->colorspace;
1544
2/2
✓ Branch 0 taken 406495 times.
✓ Branch 1 taken 218 times.
406713 if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
1545 406495 frame->color_range = avctx->color_range;
1546
1/2
✓ Branch 0 taken 406713 times.
✗ Branch 1 not taken.
406713 if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
1547 406713 frame->chroma_location = avctx->chroma_sample_location;
1548
1549
2/3
✓ Branch 0 taken 119271 times.
✓ Branch 1 taken 287442 times.
✗ Branch 2 not taken.
406713 switch (avctx->codec->type) {
1550 119271 case AVMEDIA_TYPE_VIDEO:
1551 119271 frame->format = avctx->pix_fmt;
1552
2/2
✓ Branch 0 taken 119152 times.
✓ Branch 1 taken 119 times.
119271 if (!frame->sample_aspect_ratio.num)
1553 119152 frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
1554
1555
4/6
✓ Branch 0 taken 97875 times.
✓ Branch 1 taken 21396 times.
✓ Branch 2 taken 97875 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 97875 times.
217146 if (frame->width && frame->height &&
1556 97875 av_image_check_sar(frame->width, frame->height,
1557 frame->sample_aspect_ratio) < 0) {
1558 av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1559 frame->sample_aspect_ratio.num,
1560 frame->sample_aspect_ratio.den);
1561 frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1562 }
1563
1564 119271 break;
1565 287442 case AVMEDIA_TYPE_AUDIO:
1566
1/2
✓ Branch 0 taken 287442 times.
✗ Branch 1 not taken.
287442 if (!frame->sample_rate)
1567 287442 frame->sample_rate = avctx->sample_rate;
1568
1/2
✓ Branch 0 taken 287442 times.
✗ Branch 1 not taken.
287442 if (frame->format < 0)
1569 287442 frame->format = avctx->sample_fmt;
1570
1/2
✓ Branch 0 taken 287442 times.
✗ Branch 1 not taken.
287442 if (!frame->channel_layout) {
1571
2/2
✓ Branch 0 taken 286365 times.
✓ Branch 1 taken 1077 times.
287442 if (avctx->channel_layout) {
1572 286365 if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
1573
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 286365 times.
286365 avctx->channels) {
1574 av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
1575 "configuration.\n");
1576 return AVERROR(EINVAL);
1577 }
1578
1579 286365 frame->channel_layout = avctx->channel_layout;
1580 } else {
1581
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1077 times.
1077 if (avctx->channels > FF_SANE_NB_CHANNELS) {
1582 av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
1583 avctx->channels);
1584 return AVERROR(ENOSYS);
1585 }
1586 }
1587 }
1588 287442 frame->channels = avctx->channels;
1589 287442 break;
1590 }
1591 406713 return 0;
1592 }
1593
1594 379907 static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
1595 {
1596
2/2
✓ Branch 0 taken 92465 times.
✓ Branch 1 taken 287442 times.
379907 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1597 int i;
1598 92465 int num_planes = av_pix_fmt_count_planes(frame->format);
1599 92465 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
1600
1/2
✓ Branch 0 taken 92465 times.
✗ Branch 1 not taken.
92465 int flags = desc ? desc->flags : 0;
1601
4/4
✓ Branch 0 taken 7828 times.
✓ Branch 1 taken 84637 times.
✓ Branch 2 taken 2094 times.
✓ Branch 3 taken 5734 times.
92465 if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1602 2094 num_planes = 2;
1603
2/2
✓ Branch 0 taken 264490 times.
✓ Branch 1 taken 92465 times.
356955 for (i = 0; i < num_planes; i++) {
1604
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 264490 times.
264490 av_assert0(frame->data[i]);
1605 }
1606 // For formats without data like hwaccel allow unused pointers to be non-NULL.
1607
3/4
✓ Branch 0 taken 567695 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 475230 times.
✓ Branch 3 taken 92465 times.
567695 for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1608
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 475230 times.
475230 if (frame->data[i])
1609 av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1610 475230 frame->data[i] = NULL;
1611 }
1612 }
1613 379907 }
1614
1615 379907 static void decode_data_free(void *opaque, uint8_t *data)
1616 {
1617 379907 FrameDecodeData *fdd = (FrameDecodeData*)data;
1618
1619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (fdd->post_process_opaque_free)
1620 fdd->post_process_opaque_free(fdd->post_process_opaque);
1621
1622
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (fdd->hwaccel_priv_free)
1623 fdd->hwaccel_priv_free(fdd->hwaccel_priv);
1624
1625 379907 av_freep(&fdd);
1626 379907 }
1627
1628 379907 int ff_attach_decode_data(AVFrame *frame)
1629 {
1630 AVBufferRef *fdd_buf;
1631 FrameDecodeData *fdd;
1632
1633 av_assert1(!frame->private_ref);
1634 379907 av_buffer_unref(&frame->private_ref);
1635
1636 379907 fdd = av_mallocz(sizeof(*fdd));
1637
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (!fdd)
1638 return AVERROR(ENOMEM);
1639
1640 379907 fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1641 NULL, AV_BUFFER_FLAG_READONLY);
1642
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (!fdd_buf) {
1643 av_freep(&fdd);
1644 return AVERROR(ENOMEM);
1645 }
1646
1647 379907 frame->private_ref = fdd_buf;
1648
1649 379907 return 0;
1650 }
1651
1652 380000 int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
1653 {
1654 380000 const AVHWAccel *hwaccel = avctx->hwaccel;
1655 380000 int override_dimensions = 1;
1656 int ret;
1657
1658
2/2
✓ Branch 0 taken 92558 times.
✓ Branch 1 taken 287442 times.
380000 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1659
2/4
✓ Branch 0 taken 92558 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 92558 times.
✗ Branch 3 not taken.
185116 if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1660
2/2
✓ Branch 1 taken 93 times.
✓ Branch 2 taken 92465 times.
185116 (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) {
1661 93 av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
1662 93 ret = AVERROR(EINVAL);
1663 93 goto fail;
1664 }
1665
1666
3/4
✓ Branch 0 taken 9596 times.
✓ Branch 1 taken 82869 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 9596 times.
92465 if (frame->width <= 0 || frame->height <= 0) {
1667 82869 frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1668 82869 frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1669 82869 override_dimensions = 0;
1670 }
1671
1672
4/8
✓ Branch 0 taken 92465 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 92465 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 92465 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 92465 times.
92465 if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1673 av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1674 ret = AVERROR(EINVAL);
1675 goto fail;
1676 }
1677
1/2
✓ Branch 0 taken 287442 times.
✗ Branch 1 not taken.
287442 } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1678
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 287442 times.
287442 if (frame->nb_samples * (int64_t)avctx->channels > avctx->max_samples) {
1679 av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1680 ret = AVERROR(EINVAL);
1681 goto fail;
1682 }
1683 }
1684 379907 ret = ff_decode_frame_props(avctx, frame);
1685
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (ret < 0)
1686 goto fail;
1687
1688
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (hwaccel) {
1689 if (hwaccel->alloc_frame) {
1690 ret = hwaccel->alloc_frame(avctx, frame);
1691 goto end;
1692 }
1693 } else
1694 379907 avctx->sw_pix_fmt = avctx->pix_fmt;
1695
1696 379907 ret = avctx->get_buffer2(avctx, frame, flags);
1697
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (ret < 0)
1698 goto fail;
1699
1700 379907 validate_avframe_allocation(avctx, frame);
1701
1702 379907 ret = ff_attach_decode_data(frame);
1703
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 379907 times.
379907 if (ret < 0)
1704 goto fail;
1705
1706 379907 end:
1707
4/4
✓ Branch 0 taken 287442 times.
✓ Branch 1 taken 92465 times.
✓ Branch 2 taken 9596 times.
✓ Branch 3 taken 82869 times.
379907 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1708
2/2
✓ Branch 0 taken 33035 times.
✓ Branch 1 taken 49834 times.
82869 !(avctx->codec->caps_internal & FF_CODEC_CAP_EXPORTS_CROPPING)) {
1709 49834 frame->width = avctx->width;
1710 49834 frame->height = avctx->height;
1711 }
1712
1713 330073 fail:
1714
2/2
✓ Branch 0 taken 93 times.
✓ Branch 1 taken 379907 times.
380000 if (ret < 0) {
1715 93 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1716 93 av_frame_unref(frame);
1717 }
1718
1719 380000 return ret;
1720 }
1721
1722 6973 static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
1723 {
1724 AVFrame *tmp;
1725 int ret;
1726
1727
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6973 times.
6973 av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
1728
1729
5/8
✓ Branch 0 taken 6852 times.
✓ Branch 1 taken 121 times.
✓ Branch 2 taken 6852 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6852 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 6852 times.
6973 if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1730 av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1731 frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1732 av_frame_unref(frame);
1733 }
1734
1735
2/2
✓ Branch 0 taken 121 times.
✓ Branch 1 taken 6852 times.
6973 if (!frame->data[0])
1736 121 return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1737
1738
4/4
✓ Branch 0 taken 6851 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 5300 times.
✓ Branch 4 taken 1551 times.
6852 if ((flags & FF_REGET_BUFFER_FLAG_READONLY) || av_frame_is_writable(frame))
1739 5301 return ff_decode_frame_props(avctx, frame);
1740
1741 1551 tmp = av_frame_alloc();
1742
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1551 times.
1551 if (!tmp)
1743 return AVERROR(ENOMEM);
1744
1745 1551 av_frame_move_ref(tmp, frame);
1746
1747 1551 ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1748
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1551 times.
1551 if (ret < 0) {
1749 av_frame_free(&tmp);
1750 return ret;
1751 }
1752
1753 1551 av_frame_copy(frame, tmp);
1754 1551 av_frame_free(&tmp);
1755
1756 1551 return 0;
1757 }
1758
1759 6973 int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
1760 {
1761 6973 int ret = reget_buffer_internal(avctx, frame, flags);
1762
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6973 times.
6973 if (ret < 0)
1763 av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1764 6973 return ret;
1765 }
1766
1767 12860 int ff_decode_preinit(AVCodecContext *avctx)
1768 {
1769 12860 int ret = 0;
1770
1771 /* if the decoder init function was already called previously,
1772 * free the already allocated subtitle_header before overwriting it */
1773 12860 av_freep(&avctx->subtitle_header);
1774
1775 #if FF_API_THREAD_SAFE_CALLBACKS
1776 FF_DISABLE_DEPRECATION_WARNINGS
1777
2/2
✓ Branch 0 taken 12817 times.
✓ Branch 1 taken 43 times.
12860 if ((avctx->thread_type & FF_THREAD_FRAME) &&
1778
2/2
✓ Branch 0 taken 5791 times.
✓ Branch 1 taken 7026 times.
12817 avctx->get_buffer2 != avcodec_default_get_buffer2 &&
1779
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5791 times.
5791 !avctx->thread_safe_callbacks) {
1780 av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
1781 "custom get_buffer2() implementation which is not marked as "
1782 "thread safe. This is not supported anymore, make your "
1783 "callback thread-safe.\n");
1784 }
1785 FF_ENABLE_DEPRECATION_WARNINGS
1786 #endif
1787
1788
4/4
✓ Branch 0 taken 2835 times.
✓ Branch 1 taken 10025 times.
✓ Branch 2 taken 209 times.
✓ Branch 3 taken 2626 times.
12860 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && avctx->channels == 0 &&
1789
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 209 times.
209 !(avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)) {
1790 av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
1791 return AVERROR(EINVAL);
1792 }
1793
2/4
✓ Branch 0 taken 12860 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 12860 times.
12860 if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1794 av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1795 avctx->codec->max_lowres);
1796 avctx->lowres = avctx->codec->max_lowres;
1797 }
1798
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 12854 times.
12860 if (avctx->sub_charenc) {
1799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1800 av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1801 "supported with subtitles codecs\n");
1802 return AVERROR(EINVAL);
1803
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1804 av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1805 "subtitles character encoding will be ignored\n",
1806 avctx->codec_descriptor->name);
1807 avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
1808 } else {
1809 /* input character encoding is set for a text based subtitle
1810 * codec at this point */
1811
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
1812 6 avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
1813
1814
1/2
✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
6 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
1815 #if CONFIG_ICONV
1816 6 iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1817
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
6 if (cd == (iconv_t)-1) {
1818 ret = AVERROR(errno);
1819 av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1820 "with input character encoding \"%s\"\n", avctx->sub_charenc);
1821 return ret;
1822 }
1823 6 iconv_close(cd);
1824 #else
1825 av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1826 "conversion needs a libavcodec built with iconv support "
1827 "for this codec\n");
1828 return AVERROR(ENOSYS);
1829 #endif
1830 }
1831 }
1832 }
1833
1834 12860 avctx->pts_correction_num_faulty_pts =
1835 12860 avctx->pts_correction_num_faulty_dts = 0;
1836 12860 avctx->pts_correction_last_pts =
1837 12860 avctx->pts_correction_last_dts = INT64_MIN;
1838
1839
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12860 times.
12860 if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1840 && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
1841 av_log(avctx, AV_LOG_WARNING,
1842 "gray decoding requested but not enabled at configuration time\n");
1843
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 12855 times.
12860 if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
1844 5 avctx->export_side_data |= AV_CODEC_EXPORT_DATA_MVS;
1845 }
1846
1847 12860 ret = decode_bsfs_init(avctx);
1848
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 12860 times.
12860 if (ret < 0)
1849 return ret;
1850
1851 12860 return 0;
1852 }
1853
1854 1263 int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
1855 {
1856 size_t size;
1857 1263 const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
1858
1859
3/4
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 1239 times.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
1263 if (pal && size == AVPALETTE_SIZE) {
1860 24 memcpy(dst, pal, AVPALETTE_SIZE);
1861 24 return 1;
1862
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1239 times.
1239 } else if (pal) {
1863 av_log(logctx, AV_LOG_ERROR,
1864 "Palette size %"SIZE_SPECIFIER" is wrong\n", size);
1865 }
1866 1239 return 0;
1867 }
1868