FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/encode.c
Date: 2025-03-22 04:08:01
Exec Total Coverage
Lines: 343 494 69.4%
Functions: 25 26 96.2%
Branches: 258 408 63.2%
Line Branch Exec Source
1 /*
2 * generic encoding-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 "libavutil/attributes.h"
22 #include "libavutil/avassert.h"
23 #include "libavutil/channel_layout.h"
24 #include "libavutil/emms.h"
25 #include "libavutil/frame.h"
26 #include "libavutil/imgutils.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/mem.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/samplefmt.h"
31
32 #include "avcodec.h"
33 #include "avcodec_internal.h"
34 #include "codec_desc.h"
35 #include "codec_internal.h"
36 #include "encode.h"
37 #include "frame_thread_encoder.h"
38 #include "internal.h"
39
40 typedef struct EncodeContext {
41 AVCodecInternal avci;
42
43 /**
44 * This is set to AV_PKT_FLAG_KEY for encoders that encode intra-only
45 * formats (i.e. whose codec descriptor has AV_CODEC_PROP_INTRA_ONLY set).
46 * This is used to set said flag generically for said encoders.
47 */
48 int intra_only_flag;
49
50 /**
51 * An audio frame with less than required samples has been submitted (and
52 * potentially padded with silence). Reject all subsequent frames.
53 */
54 int last_audio_frame;
55 } EncodeContext;
56
57 904615 static EncodeContext *encode_ctx(AVCodecInternal *avci)
58 {
59 904615 return (EncodeContext*)avci;
60 }
61
62 36512 int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
63 {
64
2/4
✓ Branch 0 taken 36512 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 36512 times.
 36512 if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
65 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
66 size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
67 ✗ return AVERROR(EINVAL);
68 }
69
70
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36512 times.
 36512 av_assert0(!avpkt->data);
71
72 36512 av_fast_padded_malloc(&avctx->internal->byte_buffer,
73 36512 &avctx->internal->byte_buffer_size, size);
74 36512 avpkt->data = avctx->internal->byte_buffer;
75
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36512 times.
 36512 if (!avpkt->data) {
76 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
77 ✗ return AVERROR(ENOMEM);
78 }
79 36512 avpkt->size = size;
80
81 36512 return 0;
82 }
83
84 438575 int avcodec_default_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int flags)
85 {
86 int ret;
87
88
2/4
✓ Branch 0 taken 438575 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 438575 times.
 438575 if (avpkt->size < 0 || avpkt->size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
89 ✗ return AVERROR(EINVAL);
90
91
2/4
✓ Branch 0 taken 438575 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 438575 times.
 438575 if (avpkt->data || avpkt->buf) {
92 ✗ av_log(avctx, AV_LOG_ERROR, "avpkt->{data,buf} != NULL in avcodec_default_get_encode_buffer()\n");
93 ✗ return AVERROR(EINVAL);
94 }
95
96 438575 ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
97
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 438575 times.
 438575 if (ret < 0) {
98 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %d\n", avpkt->size);
99 ✗ return ret;
100 }
101 438575 avpkt->data = avpkt->buf->data;
102
103 438575 return 0;
104 }
105
106 438575 int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
107 {
108 int ret;
109
110
2/4
✓ Branch 0 taken 438575 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 438575 times.
 438575 if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
111 ✗ return AVERROR(EINVAL);
112
113
2/4
✓ Branch 0 taken 438575 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 438575 times.
 438575 av_assert0(!avpkt->data && !avpkt->buf);
114
115 438575 avpkt->size = size;
116 438575 ret = avctx->get_encode_buffer(avctx, avpkt, flags);
117
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 438575 times.
 438575 if (ret < 0)
118 ✗ goto fail;
119
120
2/4
✓ Branch 0 taken 438575 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 438575 times.
 438575 if (!avpkt->data || !avpkt->buf) {
121 ✗ av_log(avctx, AV_LOG_ERROR, "No buffer returned by get_encode_buffer()\n");
122 ✗ ret = AVERROR(EINVAL);
123 ✗ goto fail;
124 }
125 438575 memset(avpkt->data + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
126
127 438575 ret = 0;
128 438575 fail:
129
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 438575 times.
 438575 if (ret < 0) {
130 ✗ av_log(avctx, AV_LOG_ERROR, "get_encode_buffer() failed\n");
131 ✗ av_packet_unref(avpkt);
132 }
133
134 438575 return ret;
135 }
136
137 438649 static int encode_make_refcounted(AVCodecContext *avctx, AVPacket *avpkt)
138 {
139 438649 uint8_t *data = avpkt->data;
140 int ret;
141
142
2/2
✓ Branch 0 taken 402137 times.
✓ Branch 1 taken 36512 times.
 438649 if (avpkt->buf)
143 402137 return 0;
144
145 36512 avpkt->data = NULL;
146 36512 ret = ff_get_encode_buffer(avctx, avpkt, avpkt->size, 0);
147
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 36512 times.
 36512 if (ret < 0)
148 ✗ return ret;
149 36512 memcpy(avpkt->data, data, avpkt->size);
150
151 36512 return 0;
152 }
153
154 /**
155 * Pad last frame with silence.
156 */
157 54 static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src, int out_samples)
158 {
159 int ret;
160
161 54 frame->format = src->format;
162 54 frame->nb_samples = out_samples;
163 54 ret = av_channel_layout_copy(&frame->ch_layout, &s->ch_layout);
164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 if (ret < 0)
165 ✗ goto fail;
166 54 ret = av_frame_get_buffer(frame, 0);
167
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 if (ret < 0)
168 ✗ goto fail;
169
170 54 ret = av_frame_copy_props(frame, src);
171
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 if (ret < 0)
172 ✗ goto fail;
173
174
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
175 54 src->nb_samples, s->ch_layout.nb_channels,
176 s->sample_fmt)) < 0)
177 ✗ goto fail;
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
179 54 frame->nb_samples - src->nb_samples,
180 s->ch_layout.nb_channels, s->sample_fmt)) < 0)
181 ✗ goto fail;
182
183 54 return 0;
184
185 ✗ fail:
186 ✗ av_frame_unref(frame);
187 ✗ encode_ctx(s->internal)->last_audio_frame = 0;
188 ✗ return ret;
189 }
190
191 822 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
192 const AVSubtitle *sub)
193 {
194 int ret;
195
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 822 times.
 822 if (sub->start_display_time) {
196 ✗ av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
197 ✗ return -1;
198 }
199
200 822 ret = ffcodec(avctx->codec)->cb.encode_sub(avctx, buf, buf_size, sub);
201 822 avctx->frame_num++;
202 822 return ret;
203 }
204
205 899845 int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
206 {
207 899845 AVCodecInternal *avci = avctx->internal;
208
209
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 899845 times.
 899845 if (avci->draining)
210 ✗ return AVERROR_EOF;
211
212
2/2
✓ Branch 0 taken 455066 times.
✓ Branch 1 taken 444779 times.
 899845 if (!avci->buffer_frame->buf[0])
213 455066 return AVERROR(EAGAIN);
214
215 444779 av_frame_move_ref(frame, avci->buffer_frame);
216
217 #if FF_API_FRAME_KEY
218 FF_DISABLE_DEPRECATION_WARNINGS
219
2/2
✓ Branch 0 taken 327202 times.
✓ Branch 1 taken 117577 times.
 444779 if (frame->key_frame)
220 327202 frame->flags |= AV_FRAME_FLAG_KEY;
221 FF_ENABLE_DEPRECATION_WARNINGS
222 #endif
223 #if FF_API_INTERLACED_FRAME
224 FF_DISABLE_DEPRECATION_WARNINGS
225
2/2
✓ Branch 0 taken 8496 times.
✓ Branch 1 taken 436283 times.
 444779 if (frame->interlaced_frame)
226 8496 frame->flags |= AV_FRAME_FLAG_INTERLACED;
227
2/2
✓ Branch 0 taken 6185 times.
✓ Branch 1 taken 438594 times.
 444779 if (frame->top_field_first)
228 6185 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;
229 FF_ENABLE_DEPRECATION_WARNINGS
230 #endif
231
232 444779 return 0;
233 }
234
235 433993 int ff_encode_reordered_opaque(AVCodecContext *avctx,
236 AVPacket *pkt, const AVFrame *frame)
237 {
238
2/2
✓ Branch 0 taken 430454 times.
✓ Branch 1 taken 3539 times.
 433993 if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
239 430454 int ret = av_buffer_replace(&pkt->opaque_ref, frame->opaque_ref);
240
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 430454 times.
 430454 if (ret < 0)
241 ✗ return ret;
242 430454 pkt->opaque = frame->opaque;
243 }
244
245 433993 return 0;
246 }
247
248 445253 int ff_encode_encode_cb(AVCodecContext *avctx, AVPacket *avpkt,
249 AVFrame *frame, int *got_packet)
250 {
251 445253 const FFCodec *const codec = ffcodec(avctx->codec);
252 int ret;
253
254 445253 ret = codec->cb.encode(avctx, avpkt, frame, got_packet);
255 445253 emms_c();
256
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 445253 times.
 445253 av_assert0(ret <= 0);
257
258
3/4
✓ Branch 0 taken 445253 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6534 times.
✓ Branch 3 taken 438719 times.
 445253 if (!ret && *got_packet) {
259
2/2
✓ Branch 0 taken 438649 times.
✓ Branch 1 taken 70 times.
 438719 if (avpkt->data) {
260 438649 ret = encode_make_refcounted(avctx, avpkt);
261
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 438649 times.
 438649 if (ret < 0)
262 ✗ goto unref;
263 // Date returned by encoders must always be ref-counted
264
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 438649 times.
 438649 av_assert0(avpkt->buf);
265 }
266
267 // set the timestamps for the simple no-delay case
268 // encoders with delay have to set the timestamps themselves
269
4/4
✓ Branch 0 taken 26631 times.
✓ Branch 1 taken 412088 times.
✓ Branch 2 taken 26413 times.
✓ Branch 3 taken 218 times.
 438719 if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) ||
270
2/2
✓ Branch 0 taken 15763 times.
✓ Branch 1 taken 10650 times.
 26413 (frame && (codec->caps_internal & FF_CODEC_CAP_EOF_FLUSH))) {
271
2/2
✓ Branch 0 taken 412533 times.
✓ Branch 1 taken 15318 times.
 427851 if (avpkt->pts == AV_NOPTS_VALUE)
272 412533 avpkt->pts = frame->pts;
273
274
2/2
✓ Branch 0 taken 422852 times.
✓ Branch 1 taken 4999 times.
 427851 if (!avpkt->duration) {
275
2/2
✓ Branch 0 taken 402214 times.
✓ Branch 1 taken 20638 times.
 422852 if (frame->duration)
276 402214 avpkt->duration = frame->duration;
277
2/2
✓ Branch 0 taken 3200 times.
✓ Branch 1 taken 17438 times.
 20638 else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
278 3200 avpkt->duration = ff_samples_to_time_base(avctx,
279 3200 frame->nb_samples);
280 }
281 }
282
283 427851 ret = ff_encode_reordered_opaque(avctx, avpkt, frame);
284
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 427851 times.
 427851 if (ret < 0)
285 ✗ goto unref;
286 }
287
288 // dts equals pts unless there is reordering
289 // there can be no reordering if there is no encoder delay
290
2/2
✓ Branch 0 taken 6881 times.
✓ Branch 1 taken 431838 times.
 438719 if (!(avctx->codec_descriptor->props & AV_CODEC_PROP_REORDER) ||
291
2/2
✓ Branch 0 taken 6116 times.
✓ Branch 1 taken 765 times.
 6881 !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) ||
292
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6116 times.
 6116 (codec->caps_internal & FF_CODEC_CAP_EOF_FLUSH))
293 432603 avpkt->dts = avpkt->pts;
294 } else {
295 6534 unref:
296 6534 av_packet_unref(avpkt);
297 }
298
299
2/2
✓ Branch 0 taken 444779 times.
✓ Branch 1 taken 474 times.
 445253 if (frame)
300 444779 av_frame_unref(frame);
301
302 445253 return ret;
303 }
304
305 913995 static int encode_simple_internal(AVCodecContext *avctx, AVPacket *avpkt)
306 {
307 913995 AVCodecInternal *avci = avctx->internal;
308 913995 AVFrame *frame = avci->in_frame;
309 913995 const FFCodec *const codec = ffcodec(avctx->codec);
310 int got_packet;
311 int ret;
312
313
2/2
✓ Branch 0 taken 1894 times.
✓ Branch 1 taken 912101 times.
 913995 if (avci->draining_done)
314 1894 return AVERROR_EOF;
315
316
3/4
✓ Branch 0 taken 912101 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 899845 times.
✓ Branch 3 taken 12256 times.
 912101 if (!frame->buf[0] && !avci->draining) {
317 899845 av_frame_unref(frame);
318 899845 ret = ff_encode_get_frame(avctx, frame);
319
3/4
✓ Branch 0 taken 455066 times.
✓ Branch 1 taken 444779 times.
✓ Branch 2 taken 455066 times.
✗ Branch 3 not taken.
 899845 if (ret < 0 && ret != AVERROR_EOF)
320 455066 return ret;
321 }
322
323
2/2
✓ Branch 0 taken 12256 times.
✓ Branch 1 taken 444779 times.
 457035 if (!frame->buf[0]) {
324
2/2
✓ Branch 0 taken 11782 times.
✓ Branch 1 taken 474 times.
 12256 if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
325
2/2
✓ Branch 0 taken 6075 times.
✓ Branch 1 taken 5707 times.
 11782 avci->frame_thread_encoder))
326 6075 return AVERROR_EOF;
327
328 // Flushing is signaled with a NULL frame
329 6181 frame = NULL;
330 }
331
332 450960 got_packet = 0;
333
334
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 450960 times.
 450960 av_assert0(codec->cb_type == FF_CODEC_CB_TYPE_ENCODE);
335
336
2/2
✓ Branch 0 taken 63333 times.
✓ Branch 1 taken 387627 times.
 450960 if (CONFIG_FRAME_THREAD_ENCODER && avci->frame_thread_encoder)
337 /* This will unref frame. */
338 63333 ret = ff_thread_video_encode_frame(avctx, avpkt, frame, &got_packet);
339 else {
340 387627 ret = ff_encode_encode_cb(avctx, avpkt, frame, &got_packet);
341 }
342
343
4/4
✓ Branch 0 taken 6181 times.
✓ Branch 1 taken 444779 times.
✓ Branch 2 taken 1894 times.
✓ Branch 3 taken 4287 times.
 450960 if (avci->draining && !got_packet)
344 1894 avci->draining_done = 1;
345
346 450960 return ret;
347 }
348
349 901754 static int encode_simple_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
350 {
351 int ret;
352
353
4/4
✓ Branch 0 taken 914065 times.
✓ Branch 1 taken 438649 times.
✓ Branch 2 taken 913995 times.
✓ Branch 3 taken 70 times.
 1352714 while (!avpkt->data && !avpkt->side_data) {
354 913995 ret = encode_simple_internal(avctx, avpkt);
355
2/2
✓ Branch 0 taken 463035 times.
✓ Branch 1 taken 450960 times.
 913995 if (ret < 0)
356 463035 return ret;
357 }
358
359 438719 return 0;
360 }
361
362 907943 static int encode_receive_packet_internal(AVCodecContext *avctx, AVPacket *avpkt)
363 {
364 907943 AVCodecInternal *avci = avctx->internal;
365 int ret;
366
367
2/2
✓ Branch 0 taken 6189 times.
✓ Branch 1 taken 901754 times.
 907943 if (avci->draining_done)
368 6189 return AVERROR_EOF;
369
370
2/4
✓ Branch 0 taken 901754 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 901754 times.
 901754 av_assert0(!avpkt->data && !avpkt->side_data);
371
372
2/2
✓ Branch 0 taken 287583 times.
✓ Branch 1 taken 614171 times.
 901754 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
373
3/4
✓ Branch 0 taken 808 times.
✓ Branch 1 taken 286775 times.
✓ Branch 2 taken 808 times.
✗ Branch 3 not taken.
 287583 if ((avctx->flags & AV_CODEC_FLAG_PASS1) && avctx->stats_out)
374 808 avctx->stats_out[0] = '\0';
375
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 287583 times.
 287583 if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
376 ✗ return AVERROR(EINVAL);
377 }
378
379
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 901754 times.
 901754 if (ffcodec(avctx->codec)->cb_type == FF_CODEC_CB_TYPE_RECEIVE_PACKET) {
380 ✗ ret = ffcodec(avctx->codec)->cb.receive_packet(avctx, avpkt);
381 ✗ if (ret < 0)
382 ✗ av_packet_unref(avpkt);
383 else
384 // Encoders must always return ref-counted buffers.
385 // Side-data only packets have no data and can be not ref-counted.
386 ✗ av_assert0(!avpkt->data || avpkt->buf);
387 } else
388 901754 ret = encode_simple_receive_packet(avctx, avpkt);
389
2/2
✓ Branch 0 taken 438719 times.
✓ Branch 1 taken 463035 times.
 901754 if (ret >= 0)
390 438719 avpkt->flags |= encode_ctx(avci)->intra_only_flag;
391
392
2/2
✓ Branch 0 taken 7969 times.
✓ Branch 1 taken 893785 times.
 901754 if (ret == AVERROR_EOF)
393 7969 avci->draining_done = 1;
394
395 901754 return ret;
396 }
397
398 #if CONFIG_LCMS2
399 static int encode_generate_icc_profile(AVCodecContext *avctx, AVFrame *frame)
400 {
401 enum AVColorTransferCharacteristic trc = frame->color_trc;
402 enum AVColorPrimaries prim = frame->color_primaries;
403 const FFCodec *const codec = ffcodec(avctx->codec);
404 AVCodecInternal *avci = avctx->internal;
405 cmsHPROFILE profile;
406 int ret;
407
408 /* don't generate ICC profiles if disabled or unsupported */
409 if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
410 return 0;
411 if (!(codec->caps_internal & FF_CODEC_CAP_ICC_PROFILES))
412 return 0;
413
414 if (trc == AVCOL_TRC_UNSPECIFIED)
415 trc = avctx->color_trc;
416 if (prim == AVCOL_PRI_UNSPECIFIED)
417 prim = avctx->color_primaries;
418 if (trc == AVCOL_TRC_UNSPECIFIED || prim == AVCOL_PRI_UNSPECIFIED)
419 return 0; /* can't generate ICC profile with missing csp tags */
420
421 if (av_frame_get_side_data(frame, AV_FRAME_DATA_ICC_PROFILE))
422 return 0; /* don't overwrite existing ICC profile */
423
424 if (!avci->icc.avctx) {
425 ret = ff_icc_context_init(&avci->icc, avctx);
426 if (ret < 0)
427 return ret;
428 }
429
430 ret = ff_icc_profile_generate(&avci->icc, prim, trc, &profile);
431 if (ret < 0)
432 return ret;
433
434 ret = ff_icc_profile_attach(&avci->icc, profile, frame);
435 cmsCloseProfile(profile);
436 return ret;
437 }
438 #else /* !CONFIG_LCMS2 */
439 138406 static int encode_generate_icc_profile(av_unused AVCodecContext *c, av_unused AVFrame *f)
440 {
441 138406 return 0;
442 }
443 #endif
444
445 444779 static int encode_send_frame_internal(AVCodecContext *avctx, const AVFrame *src)
446 {
447 444779 AVCodecInternal *avci = avctx->internal;
448 444779 EncodeContext *ec = encode_ctx(avci);
449 444779 AVFrame *dst = avci->buffer_frame;
450 int ret;
451
452
2/2
✓ Branch 0 taken 306373 times.
✓ Branch 1 taken 138406 times.
 444779 if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
453 /* extract audio service type metadata */
454 306373 AVFrameSideData *sd = av_frame_get_side_data(src, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
455
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 306373 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 306373 if (sd && sd->size >= sizeof(enum AVAudioServiceType))
456 ✗ avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
457
458 /* check for valid frame size */
459
2/2
✓ Branch 0 taken 73594 times.
✓ Branch 1 taken 232779 times.
 306373 if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
460 /* if we already got an undersized frame, that must have been the last */
461
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 73594 times.
 73594 if (ec->last_audio_frame) {
462 ✗ av_log(avctx, AV_LOG_ERROR, "frame_size (%d) was not respected for a non-last frame\n", avctx->frame_size);
463 ✗ return AVERROR(EINVAL);
464 }
465
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 73594 times.
 73594 if (src->nb_samples > avctx->frame_size) {
466 ✗ av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) > frame_size (%d)\n", src->nb_samples, avctx->frame_size);
467 ✗ return AVERROR(EINVAL);
468 }
469
2/2
✓ Branch 0 taken 161 times.
✓ Branch 1 taken 73433 times.
 73594 if (src->nb_samples < avctx->frame_size) {
470 161 ec->last_audio_frame = 1;
471
2/2
✓ Branch 0 taken 54 times.
✓ Branch 1 taken 107 times.
 161 if (!(avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)) {
472
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 52 times.
 54 int pad_samples = avci->pad_samples ? avci->pad_samples : avctx->frame_size;
473 54 int out_samples = (src->nb_samples + pad_samples - 1) / pad_samples * pad_samples;
474
475
1/2
✓ Branch 0 taken 54 times.
✗ Branch 1 not taken.
 54 if (out_samples != src->nb_samples) {
476 54 ret = pad_last_frame(avctx, dst, src, out_samples);
477
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 54 times.
 54 if (ret < 0)
478 ✗ return ret;
479 54 goto finish;
480 }
481 }
482 }
483 }
484 }
485
486 444725 ret = av_frame_ref(dst, src);
487
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 444725 times.
 444725 if (ret < 0)
488 ✗ return ret;
489
490 444725 finish:
491
492
2/2
✓ Branch 0 taken 138406 times.
✓ Branch 1 taken 306373 times.
 444779 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
493 138406 ret = encode_generate_icc_profile(avctx, dst);
494
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 138406 times.
 138406 if (ret < 0)
495 ✗ return ret;
496 }
497
498 // unset frame duration unless AV_CODEC_FLAG_FRAME_DURATION is set,
499 // since otherwise we cannot be sure that whatever value it has is in the
500 // right timebase, so we would produce an incorrect value, which is worse
501 // than none at all
502
2/2
✓ Branch 0 taken 3260 times.
✓ Branch 1 taken 441519 times.
 444779 if (!(avctx->flags & AV_CODEC_FLAG_FRAME_DURATION))
503 3260 dst->duration = 0;
504
505 444779 return 0;
506 }
507
508 452748 int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
509 {
510 452748 AVCodecInternal *avci = avctx->internal;
511 int ret;
512
513
2/4
✓ Branch 1 taken 452748 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 452748 times.
 452748 if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
514 ✗ return AVERROR(EINVAL);
515
516
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 452748 times.
 452748 if (avci->draining)
517 ✗ return AVERROR_EOF;
518
519
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 452748 times.
 452748 if (avci->buffer_frame->buf[0])
520 ✗ return AVERROR(EAGAIN);
521
522
2/2
✓ Branch 0 taken 7969 times.
✓ Branch 1 taken 444779 times.
 452748 if (!frame) {
523 7969 avci->draining = 1;
524 } else {
525 444779 ret = encode_send_frame_internal(avctx, frame);
526
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 444779 times.
 444779 if (ret < 0)
527 ✗ return ret;
528 }
529
530
2/4
✓ Branch 0 taken 452748 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 452748 times.
✗ Branch 3 not taken.
 452748 if (!avci->buffer_pkt->data && !avci->buffer_pkt->side_data) {
531 452748 ret = encode_receive_packet_internal(avctx, avci->buffer_pkt);
532
5/6
✓ Branch 0 taken 16536 times.
✓ Branch 1 taken 436212 times.
✓ Branch 2 taken 6189 times.
✓ Branch 3 taken 10347 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 6189 times.
 452748 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
533 ✗ return ret;
534 }
535
536 452748 avctx->frame_num++;
537
538 452748 return 0;
539 }
540
541 891407 int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
542 {
543 891407 AVCodecInternal *avci = avctx->internal;
544 int ret;
545
546 891407 av_packet_unref(avpkt);
547
548
2/4
✓ Branch 1 taken 891407 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 891407 times.
 891407 if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
549 ✗ return AVERROR(EINVAL);
550
551
4/4
✓ Branch 0 taken 455265 times.
✓ Branch 1 taken 436142 times.
✓ Branch 2 taken 70 times.
✓ Branch 3 taken 455195 times.
 891407 if (avci->buffer_pkt->data || avci->buffer_pkt->side_data) {
552 436212 av_packet_move_ref(avpkt, avci->buffer_pkt);
553 } else {
554 455195 ret = encode_receive_packet_internal(avctx, avpkt);
555
2/2
✓ Branch 0 taken 452688 times.
✓ Branch 1 taken 2507 times.
 455195 if (ret < 0)
556 452688 return ret;
557 }
558
559 438719 return 0;
560 }
561
562 19733 static int encode_preinit_video(AVCodecContext *avctx)
563 {
564 19733 const AVCodec *c = avctx->codec;
565 19733 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
566 const enum AVPixelFormat *pix_fmts;
567 int ret, i, num_pix_fmts;
568
569
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 19733 times.
 19733 if (!av_get_pix_fmt_name(avctx->pix_fmt)) {
570 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid video pixel format: %d\n",
571 ✗ avctx->pix_fmt);
572 ✗ return AVERROR(EINVAL);
573 }
574
575 19733 ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_PIX_FORMAT,
576 0, (const void **) &pix_fmts, &num_pix_fmts);
577
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19733 times.
 19733 if (ret < 0)
578 ✗ return ret;
579
580
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 18933 times.
 19733 if (pix_fmts) {
581
1/2
✓ Branch 0 taken 2648 times.
✗ Branch 1 not taken.
 2648 for (i = 0; i < num_pix_fmts; i++)
582
2/2
✓ Branch 0 taken 800 times.
✓ Branch 1 taken 1848 times.
 2648 if (avctx->pix_fmt == pix_fmts[i])
583 800 break;
584
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 800 times.
 800 if (i == num_pix_fmts) {
585 ✗ av_log(avctx, AV_LOG_ERROR,
586 "Specified pixel format %s is not supported by the %s encoder.\n",
587 ✗ av_get_pix_fmt_name(avctx->pix_fmt), c->name);
588
589 ✗ av_log(avctx, AV_LOG_ERROR, "Supported pixel formats:\n");
590 ✗ for (int p = 0; pix_fmts[p] != AV_PIX_FMT_NONE; p++) {
591 ✗ av_log(avctx, AV_LOG_ERROR, " %s\n",
592 ✗ av_get_pix_fmt_name(pix_fmts[p]));
593 }
594
595 ✗ return AVERROR(EINVAL);
596 }
597
2/2
✓ Branch 0 taken 779 times.
✓ Branch 1 taken 21 times.
 800 if (pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
598
1/2
✓ Branch 0 taken 779 times.
✗ Branch 1 not taken.
 779 pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
599
2/2
✓ Branch 0 taken 775 times.
✓ Branch 1 taken 4 times.
 779 pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
600
1/2
✓ Branch 0 taken 775 times.
✗ Branch 1 not taken.
 775 pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
601
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 767 times.
 775 pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
602 33 avctx->color_range = AVCOL_RANGE_JPEG;
603 }
604
605
1/2
✓ Branch 0 taken 19733 times.
✗ Branch 1 not taken.
 19733 if ( avctx->bits_per_raw_sample < 0
606
3/4
✓ Branch 0 taken 83 times.
✓ Branch 1 taken 19650 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 83 times.
 19733 || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
607 ✗ av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
608 ✗ avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
609 ✗ avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
610 }
611
2/4
✓ Branch 0 taken 19733 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 19733 times.
 19733 if (avctx->width <= 0 || avctx->height <= 0) {
612 ✗ av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
613 ✗ return AVERROR(EINVAL);
614 }
615
616 #if FF_API_TICKS_PER_FRAME
617 FF_DISABLE_DEPRECATION_WARNINGS
618
2/4
✓ Branch 0 taken 19733 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 19733 times.
✗ Branch 3 not taken.
 19733 if (avctx->ticks_per_frame && avctx->time_base.num &&
619
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19733 times.
 19733 avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
620 ✗ av_log(avctx, AV_LOG_ERROR,
621 "ticks_per_frame %d too large for the timebase %d/%d.",
622 avctx->ticks_per_frame,
623 avctx->time_base.num,
624 avctx->time_base.den);
625 ✗ return AVERROR(EINVAL);
626 }
627 FF_ENABLE_DEPRECATION_WARNINGS
628 #endif
629
630
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 19733 times.
 19733 if (avctx->hw_frames_ctx) {
631 ✗ AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
632 ✗ if (frames_ctx->format != avctx->pix_fmt) {
633 ✗ av_log(avctx, AV_LOG_ERROR,
634 "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
635 ✗ return AVERROR(EINVAL);
636 }
637 ✗ if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
638 ✗ avctx->sw_pix_fmt != frames_ctx->sw_format) {
639 ✗ av_log(avctx, AV_LOG_ERROR,
640 "Mismatching AVCodecContext.sw_pix_fmt (%s) "
641 "and AVHWFramesContext.sw_format (%s)\n",
642 av_get_pix_fmt_name(avctx->sw_pix_fmt),
643 av_get_pix_fmt_name(frames_ctx->sw_format));
644 ✗ return AVERROR(EINVAL);
645 }
646 ✗ avctx->sw_pix_fmt = frames_ctx->sw_format;
647 }
648
649 19733 return 0;
650 }
651
652 1346 static int encode_preinit_audio(AVCodecContext *avctx)
653 {
654 1346 const AVCodec *c = avctx->codec;
655 const enum AVSampleFormat *sample_fmts;
656 const int *supported_samplerates;
657 const AVChannelLayout *ch_layouts;
658 int ret, i, num_sample_fmts, num_samplerates, num_ch_layouts;
659
660
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1346 times.
 1346 if (!av_get_sample_fmt_name(avctx->sample_fmt)) {
661 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid audio sample format: %d\n",
662 ✗ avctx->sample_fmt);
663 ✗ return AVERROR(EINVAL);
664 }
665
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1346 times.
 1346 if (avctx->sample_rate <= 0) {
666 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid audio sample rate: %d\n",
667 avctx->sample_rate);
668 ✗ return AVERROR(EINVAL);
669 }
670
671 1346 ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_SAMPLE_FORMAT,
672 0, (const void **) &sample_fmts,
673 &num_sample_fmts);
674
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1346 times.
 1346 if (ret < 0)
675 ✗ return ret;
676
1/2
✓ Branch 0 taken 1346 times.
✗ Branch 1 not taken.
 1346 if (sample_fmts) {
677
1/2
✓ Branch 0 taken 1363 times.
✗ Branch 1 not taken.
 1363 for (i = 0; i < num_sample_fmts; i++) {
678
2/2
✓ Branch 0 taken 1346 times.
✓ Branch 1 taken 17 times.
 1363 if (avctx->sample_fmt == sample_fmts[i])
679 1346 break;
680
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
 21 if (avctx->ch_layout.nb_channels == 1 &&
681 4 av_get_planar_sample_fmt(avctx->sample_fmt) ==
682 4 av_get_planar_sample_fmt(sample_fmts[i])) {
683 ✗ avctx->sample_fmt = sample_fmts[i];
684 ✗ break;
685 }
686 }
687
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1346 times.
 1346 if (i == num_sample_fmts) {
688 ✗ av_log(avctx, AV_LOG_ERROR,
689 "Specified sample format %s is not supported by the %s encoder\n",
690 ✗ av_get_sample_fmt_name(avctx->sample_fmt), c->name);
691
692 ✗ av_log(avctx, AV_LOG_ERROR, "Supported sample formats:\n");
693 ✗ for (int p = 0; sample_fmts[p] != AV_SAMPLE_FMT_NONE; p++) {
694 ✗ av_log(avctx, AV_LOG_ERROR, " %s\n",
695 ✗ av_get_sample_fmt_name(sample_fmts[p]));
696 }
697
698 ✗ return AVERROR(EINVAL);
699 }
700 }
701
702 1346 ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_SAMPLE_RATE,
703 0, (const void **) &supported_samplerates,
704 &num_samplerates);
705
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1346 times.
 1346 if (ret < 0)
706 ✗ return ret;
707
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 1286 times.
 1346 if (supported_samplerates) {
708
1/2
✓ Branch 0 taken 130 times.
✗ Branch 1 not taken.
 130 for (i = 0; i < num_samplerates; i++)
709
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 70 times.
 130 if (avctx->sample_rate == supported_samplerates[i])
710 60 break;
711
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
 60 if (i == num_samplerates) {
712 ✗ av_log(avctx, AV_LOG_ERROR,
713 "Specified sample rate %d is not supported by the %s encoder\n",
714 ✗ avctx->sample_rate, c->name);
715
716 ✗ av_log(avctx, AV_LOG_ERROR, "Supported sample rates:\n");
717 ✗ for (int p = 0; supported_samplerates[p]; p++)
718 ✗ av_log(avctx, AV_LOG_ERROR, " %d\n", supported_samplerates[p]);
719
720 ✗ return AVERROR(EINVAL);
721 }
722 }
723 1346 ret = avcodec_get_supported_config(avctx, NULL, AV_CODEC_CONFIG_CHANNEL_LAYOUT,
724 0, (const void **) &ch_layouts, &num_ch_layouts);
725
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1346 times.
 1346 if (ret < 0)
726 ✗ return ret;
727
2/2
✓ Branch 0 taken 78 times.
✓ Branch 1 taken 1268 times.
 1346 if (ch_layouts) {
728
1/2
✓ Branch 0 taken 125 times.
✗ Branch 1 not taken.
 125 for (i = 0; i < num_ch_layouts; i++) {
729
2/2
✓ Branch 1 taken 78 times.
✓ Branch 2 taken 47 times.
 125 if (!av_channel_layout_compare(&avctx->ch_layout, &ch_layouts[i]))
730 78 break;
731 }
732
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
 78 if (i == num_ch_layouts) {
733 char buf[512];
734 ✗ int ret = av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf));
735 ✗ av_log(avctx, AV_LOG_ERROR,
736 "Specified channel layout '%s' is not supported by the %s encoder\n",
737 ✗ ret > 0 ? buf : "?", c->name);
738
739 ✗ av_log(avctx, AV_LOG_ERROR, "Supported channel layouts:\n");
740 ✗ for (int p = 0; ch_layouts[p].nb_channels; p++) {
741 ✗ ret = av_channel_layout_describe(&ch_layouts[p], buf, sizeof(buf));
742 ✗ av_log(avctx, AV_LOG_ERROR, " %s\n", ret > 0 ? buf : "?");
743 }
744 ✗ return AVERROR(EINVAL);
745 }
746 }
747
748
2/2
✓ Branch 0 taken 1293 times.
✓ Branch 1 taken 53 times.
 1346 if (!avctx->bits_per_raw_sample)
749 1293 avctx->bits_per_raw_sample = av_get_exact_bits_per_sample(avctx->codec_id);
750
2/2
✓ Branch 0 taken 170 times.
✓ Branch 1 taken 1176 times.
 1346 if (!avctx->bits_per_raw_sample)
751 170 avctx->bits_per_raw_sample = 8 * av_get_bytes_per_sample(avctx->sample_fmt);
752
753 1346 return 0;
754 }
755
756 21117 int ff_encode_preinit(AVCodecContext *avctx)
757 {
758 21117 AVCodecInternal *avci = avctx->internal;
759 21117 EncodeContext *ec = encode_ctx(avci);
760 21117 int ret = 0;
761
762
2/4
✓ Branch 0 taken 21117 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 21117 times.
 21117 if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
763 ✗ av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
764 ✗ return AVERROR(EINVAL);
765 }
766
767
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21117 times.
 21117 if (avctx->bit_rate < 0) {
768 ✗ av_log(avctx, AV_LOG_ERROR, "The encoder bitrate is negative.\n");
769 ✗ return AVERROR(EINVAL);
770 }
771
772
2/2
✓ Branch 0 taken 21028 times.
✓ Branch 1 taken 89 times.
 21117 if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE &&
773
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21028 times.
 21028 !(avctx->codec->capabilities & AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE)) {
774 ✗ av_log(avctx, AV_LOG_ERROR, "The copy_opaque flag is set, but the "
775 "encoder does not support it.\n");
776 ✗ return AVERROR(EINVAL);
777 }
778
779
3/3
✓ Branch 0 taken 19733 times.
✓ Branch 1 taken 1346 times.
✓ Branch 2 taken 38 times.
 21117 switch (avctx->codec_type) {
780 19733 case AVMEDIA_TYPE_VIDEO: ret = encode_preinit_video(avctx); break;
781 1346 case AVMEDIA_TYPE_AUDIO: ret = encode_preinit_audio(avctx); break;
782 }
783
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21117 times.
 21117 if (ret < 0)
784 ✗ return ret;
785
786
4/4
✓ Branch 0 taken 1384 times.
✓ Branch 1 taken 19733 times.
✓ Branch 2 taken 1346 times.
✓ Branch 3 taken 38 times.
 21117 if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
787
3/4
✓ Branch 0 taken 21058 times.
✓ Branch 1 taken 21 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 21058 times.
 21079 && avctx->bit_rate>0 && avctx->bit_rate<1000) {
788 ✗ av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
789 }
790
791
2/2
✓ Branch 0 taken 21115 times.
✓ Branch 1 taken 2 times.
 21117 if (!avctx->rc_initial_buffer_occupancy)
792 21115 avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
793
794
2/2
✓ Branch 0 taken 20732 times.
✓ Branch 1 taken 385 times.
 21117 if (avctx->codec_descriptor->props & AV_CODEC_PROP_INTRA_ONLY)
795 20732 ec->intra_only_flag = AV_PKT_FLAG_KEY;
796
797
2/2
✓ Branch 1 taken 21079 times.
✓ Branch 2 taken 38 times.
 21117 if (ffcodec(avctx->codec)->cb_type == FF_CODEC_CB_TYPE_ENCODE) {
798 21079 avci->in_frame = av_frame_alloc();
799
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21079 times.
 21079 if (!avci->in_frame)
800 ✗ return AVERROR(ENOMEM);
801 }
802
803
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 21115 times.
 21117 if ((avctx->flags & AV_CODEC_FLAG_RECON_FRAME)) {
804
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!(avctx->codec->capabilities & AV_CODEC_CAP_ENCODER_RECON_FRAME)) {
805 ✗ av_log(avctx, AV_LOG_ERROR, "Reconstructed frame output requested "
806 "from an encoder not supporting it\n");
807 ✗ return AVERROR(ENOSYS);
808 }
809
810 2 avci->recon_frame = av_frame_alloc();
811
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 if (!avci->recon_frame)
812 ✗ return AVERROR(ENOMEM);
813 }
814
815
2/2
✓ Branch 0 taken 190053 times.
✓ Branch 1 taken 21117 times.
 211170 for (int i = 0; ff_sd_global_map[i].packet < AV_PKT_DATA_NB; i++) {
816 190053 const enum AVPacketSideDataType type_packet = ff_sd_global_map[i].packet;
817 190053 const enum AVFrameSideDataType type_frame = ff_sd_global_map[i].frame;
818 const AVFrameSideData *sd_frame;
819 AVPacketSideData *sd_packet;
820
821 190053 sd_frame = av_frame_side_data_get(avctx->decoded_side_data,
822 avctx->nb_decoded_side_data,
823 type_frame);
824
3/4
✓ Branch 0 taken 232 times.
✓ Branch 1 taken 189821 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 232 times.
 190285 if (!sd_frame ||
825 232 av_packet_side_data_get(avctx->coded_side_data, avctx->nb_coded_side_data,
826 type_packet))
827
828 189821 continue;
829
830 232 sd_packet = av_packet_side_data_new(&avctx->coded_side_data, &avctx->nb_coded_side_data,
831 232 type_packet, sd_frame->size, 0);
832
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 232 times.
 232 if (!sd_packet)
833 ✗ return AVERROR(ENOMEM);
834
835 232 memcpy(sd_packet->data, sd_frame->data, sd_frame->size);
836 }
837
838 if (CONFIG_FRAME_THREAD_ENCODER) {
839 21117 ret = ff_frame_thread_encoder_init(avctx);
840
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21117 times.
 21117 if (ret < 0)
841 ✗ return ret;
842 }
843
844 21117 return 0;
845 }
846
847 10882 int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
848 {
849 int ret;
850
851
1/3
✓ Branch 0 taken 10882 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
 10882 switch (avctx->codec->type) {
852 10882 case AVMEDIA_TYPE_VIDEO:
853 10882 frame->format = avctx->pix_fmt;
854
3/4
✓ Branch 0 taken 10866 times.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10866 times.
 10882 if (frame->width <= 0 || frame->height <= 0) {
855 16 frame->width = FFMAX(avctx->width, avctx->coded_width);
856 16 frame->height = FFMAX(avctx->height, avctx->coded_height);
857 }
858
859 10882 break;
860 ✗ case AVMEDIA_TYPE_AUDIO:
861 ✗ frame->sample_rate = avctx->sample_rate;
862 ✗ frame->format = avctx->sample_fmt;
863 ✗ if (!frame->ch_layout.nb_channels) {
864 ✗ ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
865 ✗ if (ret < 0)
866 ✗ return ret;
867 }
868 ✗ break;
869 }
870
871 10882 ret = avcodec_default_get_buffer2(avctx, frame, 0);
872
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10882 times.
 10882 if (ret < 0) {
873 ✗ av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
874 ✗ av_frame_unref(frame);
875 ✗ return ret;
876 }
877
878 10882 return 0;
879 }
880
881 60 int ff_encode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
882 {
883 60 AVCodecInternal *avci = avctx->internal;
884
885
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
 60 if (!avci->recon_frame)
886 ✗ return AVERROR(EINVAL);
887
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 60 times.
 60 if (!avci->recon_frame->buf[0])
888 ✗ return avci->draining_done ? AVERROR_EOF : AVERROR(EAGAIN);
889
890 60 av_frame_move_ref(frame, avci->recon_frame);
891 60 return 0;
892 }
893
894 ✗ void ff_encode_flush_buffers(AVCodecContext *avctx)
895 {
896 ✗ AVCodecInternal *avci = avctx->internal;
897
898 ✗ if (avci->in_frame)
899 ✗ av_frame_unref(avci->in_frame);
900 ✗ if (avci->recon_frame)
901 ✗ av_frame_unref(avci->recon_frame);
902 ✗ }
903
904 21117 AVCodecInternal *ff_encode_internal_alloc(void)
905 {
906 21117 return av_mallocz(sizeof(EncodeContext));
907 }
908
909 204 AVCPBProperties *ff_encode_add_cpb_side_data(AVCodecContext *avctx)
910 {
911 AVPacketSideData *tmp;
912 AVCPBProperties *props;
913 size_t size;
914 int i;
915
916
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 204 times.
 205 for (i = 0; i < avctx->nb_coded_side_data; i++)
917
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (avctx->coded_side_data[i].type == AV_PKT_DATA_CPB_PROPERTIES)
918 ✗ return (AVCPBProperties *)avctx->coded_side_data[i].data;
919
920 204 props = av_cpb_properties_alloc(&size);
921
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 204 times.
 204 if (!props)
922 ✗ return NULL;
923
924 204 tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
925
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 204 times.
 204 if (!tmp) {
926 ✗ av_freep(&props);
927 ✗ return NULL;
928 }
929
930 204 avctx->coded_side_data = tmp;
931 204 avctx->nb_coded_side_data++;
932
933 204 avctx->coded_side_data[avctx->nb_coded_side_data - 1].type = AV_PKT_DATA_CPB_PROPERTIES;
934 204 avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
935 204 avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
936
937 204 return props;
938 }
939
940 1612 int ff_check_codec_matrices(AVCodecContext *avctx, unsigned types, uint16_t min, uint16_t max)
941 {
942 1612 uint16_t *matrices[] = {avctx->intra_matrix, avctx->inter_matrix, avctx->chroma_intra_matrix};
943 1612 const char *names[] = {"Intra", "Inter", "Chroma Intra"};
944 static_assert(FF_ARRAY_ELEMS(matrices) == FF_ARRAY_ELEMS(names), "matrix count mismatch");
945
2/2
✓ Branch 0 taken 4836 times.
✓ Branch 1 taken 1612 times.
 6448 for (int m = 0; m < FF_ARRAY_ELEMS(matrices); m++) {
946 4836 uint16_t *matrix = matrices[m];
947
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 4836 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 4836 if (matrix && (types & (1U << m))) {
948 ✗ for (int i = 0; i < 64; i++) {
949 ✗ if (matrix[i] < min || matrix[i] > max) {
950 ✗ av_log(avctx, AV_LOG_ERROR, "%s matrix[%d] is %d which is out of the allowed range [%"PRIu16"-%"PRIu16"].\n", names[m], i, matrix[i], min, max);
951 ✗ return AVERROR(EINVAL);
952 }
953 }
954 }
955 }
956 1612 return 0;
957 }
958