FFmpeg coverage

../../../ffmpeg/
Coverage:
low: ≥ 0%
medium: ≥ 75.0%
high: ≥ 90.0%
Lines:
0 / 683
0.0%
Branches:
0 / 210
0.0%
Functions:
0 / 17
0.0%
libavcodec/vulkan_encode_av1.c
Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include "libavutil/opt.h"
20 #include "libavutil/mem.h"
21
22 #include "cbs.h"
23 #include "cbs_av1.h"
24 #include "av1_levels.h"
25 #include "libavutil/mastering_display_metadata.h"
26
27 #include "codec_internal.h"
28 #include "vulkan_encode.h"
29
30 #include "libavutil/avassert.h"
31
32 const FFVulkanEncodeDescriptor ff_vk_enc_av1_desc = {
33 .codec_id = AV_CODEC_ID_AV1,
34 .encode_extension = FF_VK_EXT_VIDEO_ENCODE_AV1,
35 .encode_op = VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR,
36 .ext_props = {
37 .extensionName = VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME,
38 .specVersion = VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION,
39 },
40 };
41
42 enum UnitElems {
43 UNIT_MASTERING_DISPLAY = 1 << 0,
44 UNIT_CONTENT_LIGHT_LEVEL = 1 << 1,
45 };
46
47 typedef struct VulkanEncodeAV1Picture {
48 int slot;
49 int64_t last_idr_frame;
50
51 enum UnitElems units_needed;
52
53 StdVideoAV1TileInfo tile_info;
54 StdVideoAV1Quantization quantization;
55 StdVideoAV1Segmentation segmentation;
56 StdVideoAV1LoopFilter loop_filter;
57 StdVideoAV1CDEF cdef;
58 StdVideoAV1LoopRestoration loop_restoration;
59 StdVideoAV1GlobalMotion global_motion;
60
61 StdVideoEncodeAV1PictureInfo av1pic_info;
62 VkVideoEncodeAV1PictureInfoKHR vkav1pic_info;
63
64 StdVideoEncodeAV1ExtensionHeader ext_header;
65 StdVideoEncodeAV1ReferenceInfo av1dpb_info;
66 VkVideoEncodeAV1DpbSlotInfoKHR vkav1dpb_info;
67
68 VkVideoEncodeAV1RateControlInfoKHR vkrc_info;
69 VkVideoEncodeAV1RateControlLayerInfoKHR vkrc_layer_info;
70 VkVideoEncodeAV1GopRemainingFrameInfoKHR vkrc_remaining;
71 } VulkanEncodeAV1Picture;
72
73 typedef struct VulkanEncodeAV1Context {
74 FFVulkanEncodeContext common;
75
76 CodedBitstreamContext *cbs;
77 CodedBitstreamFragment current_access_unit;
78
79 enum UnitElems unit_elems;
80 AV1RawOBU seq_hdr_obu;
81 AV1RawOBU meta_cll_obu;
82 AV1RawOBU meta_mastering_obu;
83 AV1RawOBU hidden_obu;
84 AV1RawOBU tail_obu;
85
86 VkVideoEncodeAV1ProfileInfoKHR profile;
87
88 VkVideoEncodeAV1CapabilitiesKHR caps;
89 VkVideoEncodeAV1QualityLevelPropertiesKHR quality_props;
90
91 uint64_t hrd_buffer_size;
92 uint64_t initial_buffer_fullness;
93
94 int uniform_tile;
95 int tile_cols;
96 int tile_rows;
97
98 int seq_tier;
99 int seq_level_idx;
100
101 int q_idx_idr;
102 int q_idx_p;
103 int q_idx_b;
104
105 uint8_t *padding_payload;
106 } VulkanEncodeAV1Context;
107
108 ✗ static int init_pic_rc(AVCodecContext *avctx, FFHWBaseEncodePicture *pic,
109 VkVideoEncodeRateControlInfoKHR *rc_info,
110 VkVideoEncodeRateControlLayerInfoKHR *rc_layer)
111 {
112 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
113 ✗ FFVulkanEncodeContext *ctx = &enc->common;
114 ✗ VulkanEncodeAV1Picture *ap = pic->codec_priv;
115
116 /* This can be easy to calculate */
117 ✗ ap->vkrc_remaining = (VkVideoEncodeAV1GopRemainingFrameInfoKHR) {
118 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR,
119 .useGopRemainingFrames = 0,
120 .gopRemainingIntra = 0,
121 .gopRemainingPredictive = 0,
122 .gopRemainingBipredictive = 0,
123 };
124
125 ✗ ap->vkrc_info = (VkVideoEncodeAV1RateControlInfoKHR) {
126 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR,
127 .flags = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR |
128 VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR,
129 ✗ .gopFrameCount = ctx->base.gop_size,
130 ✗ .keyFramePeriod = ctx->base.gop_size,
131 ✗ .consecutiveBipredictiveFrameCount = FFMAX(ctx->base.b_per_p - 1, 0),
132 .temporalLayerCount = 0,
133 };
134 ✗ rc_info->pNext = &ap->vkrc_info;
135
136
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
 ✗ if (rc_info->rateControlMode > VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR) {
137 ✗ rc_info->virtualBufferSizeInMs = (enc->hrd_buffer_size * 1000LL) / avctx->bit_rate;
138 ✗ rc_info->initialVirtualBufferSizeInMs = (enc->initial_buffer_fullness * 1000LL) / avctx->bit_rate;
139
140 ✗ ap->vkrc_layer_info = (VkVideoEncodeAV1RateControlLayerInfoKHR) {
141 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR,
142
143 ✗ .useMinQIndex = avctx->qmin > 0,
144 ✗ .minQIndex.intraQIndex = avctx->qmin > 0 ? avctx->qmin : 0,
145 ✗ .minQIndex.predictiveQIndex = avctx->qmin > 0 ? avctx->qmin : 0,
146 ✗ .minQIndex.bipredictiveQIndex = avctx->qmin > 0 ? avctx->qmin : 0,
147
148 ✗ .useMaxQIndex = avctx->qmax > 0,
149 ✗ .maxQIndex.intraQIndex = avctx->qmax > 0 ? avctx->qmax : 0,
150 ✗ .maxQIndex.predictiveQIndex = avctx->qmax > 0 ? avctx->qmax : 0,
151 ✗ .maxQIndex.bipredictiveQIndex = avctx->qmax > 0 ? avctx->qmax : 0,
152
153 .useMaxFrameSize = 0,
154 };
155 ✗ rc_layer->pNext = &ap->vkrc_layer_info;
156 ✗ ap->vkrc_info.temporalLayerCount = 1;
157 }
158
159 ✗ return 0;
160 }
161
162 ✗ static int set_name_slot(int slot, int *slot_indices, uint32_t allowed_idx, int group)
163 {
164
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
 ✗ int from = group ? AV1_REF_FRAME_GOLDEN : 0;
165
0/2
✗ Branch 5 → 6 not taken.
✗ Branch 5 → 7 not taken.
 ✗ int to = group ? AV1_REFS_PER_FRAME : AV1_REF_FRAME_GOLDEN;
166
167
0/2
✗ Branch 13 → 9 not taken.
✗ Branch 13 → 14 not taken.
 ✗ for (int i = from; i < to; i++) {
168
0/4
✗ Branch 9 → 10 not taken.
✗ Branch 9 → 12 not taken.
✗ Branch 10 → 11 not taken.
✗ Branch 10 → 12 not taken.
 ✗ if ((slot_indices[i] == -1) && (allowed_idx & (1 << i))) {
169 ✗ slot_indices[i] = slot;
170 ✗ return i;
171 }
172 }
173
174 ✗ av_assert0(0);
175 }
176
177 ✗ static int init_pic_params(AVCodecContext *avctx, FFHWBaseEncodePicture *pic,
178 VkVideoEncodeInfoKHR *encode_info)
179 {
180 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
181 ✗ FFVulkanEncodeContext *ctx = &enc->common;
182 ✗ FFHWBaseEncodeContext *base_ctx = &ctx->base;
183
184 ✗ VulkanEncodeAV1Picture *ap = pic->codec_priv;
185 FFHWBaseEncodePicture *ref;
186 VulkanEncodeAV1Picture *ap_ref;
187 VkVideoReferenceSlotInfoKHR *ref_slot;
188
189 ✗ uint32_t ref_name_mask = 0x0;
190 int name_slots[STD_VIDEO_AV1_REFS_PER_FRAME];
191 int name;
192
193 ✗ StdVideoAV1Segmentation *segmentation = &ap->segmentation;
194 ✗ StdVideoAV1LoopFilter *loop_filter = &ap->loop_filter;
195 ✗ StdVideoAV1Quantization *quantization = &ap->quantization;
196 ✗ StdVideoAV1CDEF *cdef = &ap->cdef;
197 ✗ StdVideoAV1LoopRestoration *loop_restoration = &ap->loop_restoration;
198 ✗ StdVideoAV1GlobalMotion *global_motion = &ap->global_motion;
199 ✗ StdVideoAV1TileInfo *tile_info = &ap->tile_info;
200 static const int8_t default_loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME] =
201 { 1, 0, 0, 0, -1, 0, -1, -1 };
202
203 VkVideoEncodeAV1PredictionModeKHR pred_mode;
204 VkVideoEncodeAV1RateControlGroupKHR rc_group;
205 ✗ int lr_unit_shift = 0;
206 ✗ int lr_uv_shift = 0;
207
208 ✗ ap->ext_header = (StdVideoEncodeAV1ExtensionHeader) {
209 .temporal_id = 0,
210 .spatial_id = 0,
211 };
212
213 ✗ *tile_info = (StdVideoAV1TileInfo) {
214 .flags = (StdVideoAV1TileInfoFlags) {
215 ✗ .uniform_tile_spacing_flag = enc->uniform_tile,
216 },
217 ✗ .TileCols = enc->tile_cols,
218 ✗ .TileRows = enc->tile_rows,
219 .context_update_tile_id = 0,
220 .tile_size_bytes_minus_1 = 0,
221 };
222
223
0/2
✗ Branch 7 → 3 not taken.
✗ Branch 7 → 8 not taken.
 ✗ for (int i = 0; i < STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME; i++) {
224 ✗ global_motion->GmType[i] = 0;
225
0/2
✗ Branch 5 → 4 not taken.
✗ Branch 5 → 6 not taken.
 ✗ for (int j = 0; j < STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS; j++) {
226 ✗ global_motion->gm_params[i][j] = 0;
227 }
228 }
229
230
0/2
✗ Branch 10 → 9 not taken.
✗ Branch 10 → 11 not taken.
 ✗ for (int i = 0; i < STD_VIDEO_AV1_REFS_PER_FRAME; i++)
231 ✗ name_slots[i] = -1;
232
233 ✗ *loop_restoration = (StdVideoAV1LoopRestoration) {
234 .FrameRestorationType[0] = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
235 .FrameRestorationType[1] = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
236 .FrameRestorationType[2] = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE,
237 ✗ .LoopRestorationSize[0] = 1 + lr_unit_shift,
238 ✗ .LoopRestorationSize[1] = 1 + lr_unit_shift - lr_uv_shift,
239 ✗ .LoopRestorationSize[2] = 1 + lr_unit_shift - lr_uv_shift,
240 };
241
242 ✗ *cdef = (StdVideoAV1CDEF) {
243 .cdef_damping_minus_3 = 0,
244 .cdef_bits = 0,
245 };
246
247
0/2
✗ Branch 16 → 12 not taken.
✗ Branch 16 → 17 not taken.
 ✗ for (int i = 0; i < STD_VIDEO_AV1_MAX_SEGMENTS; i++) {
248 ✗ segmentation->FeatureEnabled[i] = 0x0;
249
0/2
✗ Branch 14 → 13 not taken.
✗ Branch 14 → 15 not taken.
 ✗ for (int j = 0; j < STD_VIDEO_AV1_SEG_LVL_MAX; j++) {
250 ✗ segmentation->FeatureEnabled[i] |= 0x0;
251 ✗ segmentation->FeatureData[i][j] = 0;
252 }
253 }
254
255 ✗ *loop_filter = (StdVideoAV1LoopFilter) {
256 .flags = (StdVideoAV1LoopFilterFlags) {
257 .loop_filter_delta_enabled = 0,
258 .loop_filter_delta_update = 0,
259 },
260 .loop_filter_level = { 0 },
261 .loop_filter_sharpness = 0,
262 .update_ref_delta = 0,
263 .loop_filter_ref_deltas = { 0 },
264 .update_mode_delta = 0,
265 .loop_filter_mode_deltas = { 0 },
266 };
267 ✗ loop_filter->update_mode_delta = 1;
268 ✗ memcpy(loop_filter->loop_filter_ref_deltas, default_loop_filter_ref_deltas,
269 STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME * sizeof(int8_t));
270
271 ✗ *quantization = (StdVideoAV1Quantization) {
272 .flags = (StdVideoAV1QuantizationFlags) {
273 .using_qmatrix = 0,
274 .diff_uv_delta = 0,
275 /* Reserved */
276 },
277 .base_q_idx = 0, /* Set later */
278 .DeltaQYDc = 0,
279 .DeltaQUDc = 0,
280 .DeltaQUAc = 0,
281 .DeltaQVDc = 0,
282 .DeltaQVAc = 0,
283 .qm_y = 0,
284 .qm_u = 0,
285 .qm_v = 0,
286 };
287
288 ✗ ref_slot = (VkVideoReferenceSlotInfoKHR *)encode_info->pSetupReferenceSlot;
289 ✗ ap->av1pic_info = (StdVideoEncodeAV1PictureInfo) {
290 .flags = (StdVideoEncodeAV1PictureInfoFlags) {
291 ✗ .error_resilient_mode = (pic->type == FF_HW_PICTURE_TYPE_I ||
292
0/4
✗ Branch 17 → 18 not taken.
✗ Branch 17 → 19 not taken.
✗ Branch 18 → 19 not taken.
✗ Branch 18 → 21 not taken.
 ✗ pic->type == FF_HW_PICTURE_TYPE_IDR) &&
293
0/2
✗ Branch 19 → 20 not taken.
✗ Branch 19 → 21 not taken.
 ✗ (pic->display_order <= pic->encode_order),
294 .disable_cdf_update = 0,
295 .use_superres = 0,
296 .render_and_frame_size_different = 0,
297 .allow_screen_content_tools = 0,
298 .is_filter_switchable = 0,
299 .force_integer_mv = 0,
300 .frame_size_override_flag = 0,
301 .buffer_removal_time_present_flag = 0,
302 .allow_intrabc = 0,
303 .frame_refs_short_signaling = 0,
304 .allow_high_precision_mv = 0,
305 .is_motion_mode_switchable = 0,
306 .use_ref_frame_mvs = 0,
307 .disable_frame_end_update_cdf = 0,
308 .allow_warped_motion = 0,
309 .reduced_tx_set = 0,
310 .skip_mode_present = 0,
311 .delta_q_present = 0,
312 .delta_lf_present = 0,
313 .delta_lf_multi = 0,
314 .segmentation_enabled = 0,
315 .segmentation_update_map = 0,
316 .segmentation_temporal_update = 0,
317 .segmentation_update_data = 0,
318 .UsesLr = 0,
319 .usesChromaLr = 0,
320 ✗ .show_frame = pic->display_order <= pic->encode_order,
321 .showable_frame = 0,
322 /* Reserved */
323 },
324 .frame_type = 0, // set later
325 .frame_presentation_time = 0,
326 ✗ .current_frame_id = ref_slot->slotIndex,
327 .order_hint = 0, // set later
328 .primary_ref_frame = 0, // set later
329 .refresh_frame_flags = 0x0, // set later
330 .coded_denom = 0,
331 ✗ .render_width_minus_1 = base_ctx->surface_width - 1,
332 ✗ .render_height_minus_1 = base_ctx->surface_height - 1,
333 .interpolation_filter = 0,
334 .TxMode = STD_VIDEO_AV1_TX_MODE_SELECT,
335 .delta_q_res = 0,
336 .delta_lf_res = 0,
337 .ref_order_hint = { 0 }, // set later
338 .ref_frame_idx = { 0 }, // set later
339 /* Reserved */
340 .delta_frame_id_minus_1 = { 0 },
341
342 // .pTileInfo = tile_info, TODO FIX
343 .pQuantization = quantization,
344 .pSegmentation = segmentation,
345 .pLoopFilter = loop_filter,
346 .pCDEF = cdef,
347 .pLoopRestoration = loop_restoration,
348 .pGlobalMotion = global_motion,
349 ✗ .pExtensionHeader = &ap->ext_header,
350 .pBufferRemovalTimes = NULL,
351 };
352
353
0/4
✗ Branch 22 → 23 not taken.
✗ Branch 22 → 28 not taken.
✗ Branch 22 → 40 not taken.
✗ Branch 22 → 49 not taken.
 ✗ switch (pic->type) {
354 ✗ case FF_HW_PICTURE_TYPE_I:
355 case FF_HW_PICTURE_TYPE_IDR:
356
0/4
✗ Branch 23 → 24 not taken.
✗ Branch 23 → 27 not taken.
✗ Branch 24 → 25 not taken.
✗ Branch 24 → 27 not taken.
 ✗ av_assert0(pic->nb_refs[0] == 0 || pic->nb_refs[1]);
357 ✗ ap->av1pic_info.frame_type = STD_VIDEO_AV1_FRAME_TYPE_KEY;
358 ✗ ap->av1pic_info.refresh_frame_flags = 0xFF;
359 ✗ ap->av1pic_info.primary_ref_frame = STD_VIDEO_AV1_PRIMARY_REF_NONE;
360 ✗ quantization->base_q_idx = enc->q_idx_idr;
361 ✗ ap->slot = 0;
362 ✗ ap->last_idr_frame = pic->display_order;
363 ✗ pred_mode = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR;
364 ✗ rc_group = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR;
365 ✗ break;
366 ✗ case FF_HW_PICTURE_TYPE_P:
367 ✗ ref = pic->refs[0][pic->nb_refs[0] - 1];
368 ✗ ap_ref = ref->codec_priv;
369
370 ✗ ap->av1pic_info.frame_type = STD_VIDEO_AV1_FRAME_TYPE_INTER;
371 ✗ quantization->base_q_idx = enc->q_idx_p;
372
373 ✗ ap->last_idr_frame = ap_ref->last_idr_frame;
374 ✗ ap->slot = !ap_ref->slot;
375
376 ✗ ap->av1pic_info.refresh_frame_flags = 1 << ap->slot;
377
378 /** set the nearest frame in L0 as all reference frame. */
379
0/2
✗ Branch 30 → 29 not taken.
✗ Branch 30 → 31 not taken.
 ✗ for (int i = 0; i < AV1_REFS_PER_FRAME; i++)
380 ✗ ap->av1pic_info.ref_frame_idx[i] = ap_ref->slot;
381
382 ✗ ap->av1pic_info.ref_order_hint[ap_ref->slot] = ref->display_order - ap_ref->last_idr_frame;
383 ✗ rc_group = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR;
384 ✗ pred_mode = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR;
385 ✗ ref_name_mask = enc->caps.singleReferenceNameMask;
386 ✗ ap->av1pic_info.primary_ref_frame =
387 ✗ set_name_slot(ap_ref->av1pic_info.current_frame_id, name_slots, ref_name_mask, 0);
388
389 // vpic->ref_frame_ctrl_l0.fields.search_idx0 = AV1_REF_FRAME_LAST;
390
391 /** set the 2nd nearest frame in L0 as Golden frame. */
392
0/2
✗ Branch 32 → 33 not taken.
✗ Branch 32 → 39 not taken.
 ✗ if ((pic->nb_refs[0] > 1) &&
393
0/2
✗ Branch 33 → 34 not taken.
✗ Branch 33 → 35 not taken.
 ✗ ((enc->caps.maxSingleReferenceCount > 1) ||
394
0/2
✗ Branch 34 → 35 not taken.
✗ Branch 34 → 39 not taken.
 ✗ (enc->caps.maxUnidirectionalCompoundReferenceCount > 0))) {
395
0/2
✗ Branch 35 → 36 not taken.
✗ Branch 35 → 37 not taken.
 ✗ if (enc->caps.maxUnidirectionalCompoundReferenceCount) {
396 ✗ pred_mode = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR;
397 ✗ ref_name_mask = enc->caps.unidirectionalCompoundReferenceNameMask;
398 }
399 ✗ ref = pic->refs[0][pic->nb_refs[0] - 2];
400 ✗ ap_ref = ref->codec_priv;
401 ✗ ap->av1pic_info.ref_order_hint[ap_ref->slot] = ref->display_order - ap_ref->last_idr_frame;
402 /* The header must name the same reference the encoder uses for it. */
403 ✗ name = set_name_slot(ap_ref->av1pic_info.current_frame_id, name_slots, ref_name_mask, 0);
404 ✗ ap->av1pic_info.ref_frame_idx[name] = ap_ref->slot;
405 }
406 ✗ break;
407 ✗ case FF_HW_PICTURE_TYPE_B:
408 ✗ ap->av1pic_info.frame_type = STD_VIDEO_AV1_FRAME_TYPE_INTER;
409 ✗ quantization->base_q_idx = enc->q_idx_b;
410 ✗ ap->av1pic_info.refresh_frame_flags = 0x0;
411
412 ✗ rc_group = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR;
413 ✗ pred_mode = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR;
414 ✗ ref_name_mask = enc->caps.bidirectionalCompoundReferenceNameMask;
415
416 // fh->reference_select = 1;
417 /** B frame will not be referenced, disable its recon frame. */
418 // vpic->picture_flags.bits.disable_frame_recon = 1;
419
420 /** Use LAST_FRAME and BWDREF_FRAME for reference. */
421 // vpic->ref_frame_ctrl_l0.fields.search_idx0 = AV1_REF_FRAME_LAST;
422 // vpic->ref_frame_ctrl_l1.fields.search_idx0 = AV1_REF_FRAME_BWDREF;
423
424 ✗ ref = pic->refs[0][pic->nb_refs[0] - 1];
425 ✗ ap_ref = ref->codec_priv;
426 ✗ ap->last_idr_frame = ap_ref->last_idr_frame;
427 ✗ ap->av1pic_info.ref_order_hint[ap_ref->slot] = ref->display_order - ap_ref->last_idr_frame;
428
0/2
✗ Branch 42 → 41 not taken.
✗ Branch 42 → 43 not taken.
 ✗ for (int i = 0; i < AV1_REF_FRAME_GOLDEN; i++)
429 ✗ ap->av1pic_info.ref_frame_idx[i] = ap_ref->slot;
430 ✗ ap->av1pic_info.primary_ref_frame =
431 ✗ set_name_slot(ap_ref->av1pic_info.current_frame_id, name_slots, ref_name_mask, 0);
432
433 ✗ ref = pic->refs[1][pic->nb_refs[1] - 1];
434 ✗ ap_ref = ref->codec_priv;
435 ✗ ap->av1pic_info.ref_order_hint[ap_ref->slot] = ref->display_order - ap_ref->last_idr_frame;
436
0/2
✗ Branch 46 → 45 not taken.
✗ Branch 46 → 47 not taken.
 ✗ for (int i = AV1_REF_FRAME_GOLDEN; i < AV1_REFS_PER_FRAME; i++)
437 ✗ ap->av1pic_info.ref_frame_idx[i] = ap_ref->slot;
438 ✗ set_name_slot(ap_ref->av1pic_info.current_frame_id, name_slots, ref_name_mask, 1);
439 ✗ break;
440 }
441
442 ✗ ap->av1pic_info.flags.showable_frame = ap->av1pic_info.frame_type != STD_VIDEO_AV1_FRAME_TYPE_KEY;
443 ✗ ap->av1pic_info.order_hint = pic->display_order - ap->last_idr_frame;
444
445 ✗ ap->vkav1pic_info = (VkVideoEncodeAV1PictureInfoKHR) {
446 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR,
447 .pNext = NULL,
448 .predictionMode = pred_mode,
449 .rateControlGroup = rc_group,
450 ✗ .constantQIndex = quantization->base_q_idx,
451 ✗ .pStdPictureInfo = &ap->av1pic_info,
452 // .referenceNameSlotIndices is set below
453 .primaryReferenceCdfOnly = 0,
454 .generateObuExtensionHeader = 0,
455 };
456 /* With rate control on, the driver picks the quantiser; constantQIndex must be 0
457 * (VUID-vkCmdEncodeVideoKHR-constantQIndex-10320). */
458
0/2
✗ Branch 49 → 50 not taken.
✗ Branch 49 → 51 not taken.
 ✗ if (ctx->opts.rc_mode != VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR)
459 ✗ ap->vkav1pic_info.constantQIndex = 0;
460 ✗ encode_info->pNext = &ap->vkav1pic_info;
461
462
0/2
✗ Branch 53 → 52 not taken.
✗ Branch 53 → 54 not taken.
 ✗ for (int i = 0; i < FF_ARRAY_ELEMS(ap->vkav1pic_info.referenceNameSlotIndices); i++)
463 ✗ ap->vkav1pic_info.referenceNameSlotIndices[i] = name_slots[i];
464
465 ✗ ref_slot = (VkVideoReferenceSlotInfoKHR *)encode_info->pSetupReferenceSlot;
466 ✗ ref_slot->pNext = &ap->vkav1dpb_info;
467
468 ✗ ap->av1dpb_info = (StdVideoEncodeAV1ReferenceInfo) {
469 .flags = (StdVideoEncodeAV1ReferenceInfoFlags) {
470 .disable_frame_end_update_cdf = 0,
471 .segmentation_enabled = 0,
472 /* Reserved */
473 },
474 ✗ .RefFrameId = ref_slot->slotIndex,
475 ✗ .frame_type = ap->av1pic_info.frame_type,
476 ✗ .OrderHint = pic->display_order - ap->last_idr_frame,
477 /* Reserved */
478 ✗ .pExtensionHeader = &ap->ext_header,
479 };
480
481 ✗ ap->vkav1dpb_info = (VkVideoEncodeAV1DpbSlotInfoKHR) {
482 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR,
483 ✗ .pStdReferenceInfo = &ap->av1dpb_info,
484 };
485
486 ✗ ap->units_needed = 0;
487
0/2
✗ Branch 54 → 55 not taken.
✗ Branch 54 → 68 not taken.
 ✗ if (pic->type == FF_HW_PICTURE_TYPE_IDR) {
488 ✗ AVFrameSideData *sd = NULL;
489
0/2
✗ Branch 55 → 56 not taken.
✗ Branch 55 → 57 not taken.
 ✗ if (enc->unit_elems & UNIT_MASTERING_DISPLAY)
490 ✗ sd = av_frame_get_side_data(pic->input_image,
491 AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
492
0/2
✗ Branch 57 → 58 not taken.
✗ Branch 57 → 64 not taken.
 ✗ if (sd) {
493 ✗ AVMasteringDisplayMetadata *mdm =
494 (AVMasteringDisplayMetadata *)sd->data;
495
0/4
✗ Branch 58 → 59 not taken.
✗ Branch 58 → 64 not taken.
✗ Branch 59 → 60 not taken.
✗ Branch 59 → 64 not taken.
 ✗ if (mdm->has_primaries && mdm->has_luminance) {
496 ✗ AV1RawOBU *obu = &enc->meta_mastering_obu;
497 ✗ AV1RawMetadata *md = &obu->obu.metadata;
498 ✗ AV1RawMetadataHDRMDCV *mdcv = &md->metadata.hdr_mdcv;
499 ✗ const int chroma_den = 1 << 16;
500 ✗ const int max_luma_den = 1 << 8;
501 ✗ const int min_luma_den = 1 << 14;
502
503 ✗ memset(obu, 0, sizeof(*obu));
504 ✗ obu->header.obu_type = AV1_OBU_METADATA;
505 ✗ md->metadata_type = AV1_METADATA_TYPE_HDR_MDCV;
506
507
0/2
✗ Branch 62 → 61 not taken.
✗ Branch 62 → 63 not taken.
 ✗ for (int i = 0; i < 3; i++) {
508 ✗ mdcv->primary_chromaticity_x[i] =
509 ✗ av_rescale(mdm->display_primaries[i][0].num, chroma_den,
510 ✗ mdm->display_primaries[i][0].den);
511 ✗ mdcv->primary_chromaticity_y[i] =
512 ✗ av_rescale(mdm->display_primaries[i][1].num, chroma_den,
513 ✗ mdm->display_primaries[i][1].den);
514 }
515
516 ✗ mdcv->white_point_chromaticity_x =
517 ✗ av_rescale(mdm->white_point[0].num, chroma_den,
518 ✗ mdm->white_point[0].den);
519 ✗ mdcv->white_point_chromaticity_y =
520 ✗ av_rescale(mdm->white_point[1].num, chroma_den,
521 ✗ mdm->white_point[1].den);
522
523 ✗ mdcv->luminance_max =
524 ✗ av_rescale(mdm->max_luminance.num, max_luma_den,
525 ✗ mdm->max_luminance.den);
526 ✗ mdcv->luminance_min =
527 ✗ av_rescale(mdm->min_luminance.num, min_luma_den,
528 ✗ mdm->min_luminance.den);
529 ✗ ap->units_needed |= UNIT_MASTERING_DISPLAY;
530 }
531 }
532
533
0/2
✗ Branch 64 → 65 not taken.
✗ Branch 64 → 66 not taken.
 ✗ if (enc->unit_elems & UNIT_CONTENT_LIGHT_LEVEL)
534 ✗ sd = av_frame_get_side_data(pic->input_image,
535 AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
536
0/2
✗ Branch 66 → 67 not taken.
✗ Branch 66 → 68 not taken.
 ✗ if (sd) {
537 ✗ AVContentLightMetadata *cllm = (AVContentLightMetadata *)sd->data;
538 ✗ AV1RawOBU *obu = &enc->meta_cll_obu;
539 ✗ AV1RawMetadata *md = &obu->obu.metadata;
540 ✗ AV1RawMetadataHDRCLL *cll = &md->metadata.hdr_cll;
541
542 ✗ memset(obu, 0, sizeof(*obu));
543 ✗ obu->header.obu_type = AV1_OBU_METADATA;
544 ✗ md->metadata_type = AV1_METADATA_TYPE_HDR_CLL;
545 ✗ cll->max_cll = cllm->MaxCLL;
546 ✗ cll->max_fall = cllm->MaxFALL;
547
548 ✗ ap->units_needed |= UNIT_CONTENT_LIGHT_LEVEL;
549 }
550 }
551
552 ✗ FFVulkanEncodePicture *vp = pic->priv;
553 ✗ vp->tail_size = 0;
554 ✗ vp->non_independent_frame = pic->encode_order < pic->display_order;
555
0/2
✗ Branch 68 → 69 not taken.
✗ Branch 68 → 70 not taken.
 ✗ if (vp->non_independent_frame) {
556 ✗ AV1RawOBU *obu = &enc->hidden_obu;
557 ✗ AV1RawFrameHeader *fh = &obu->obu.frame_header;
558
559 /** hidden frame header */
560 ✗ memset(obu, 0, sizeof(*obu));
561 ✗ obu->header.obu_type = AV1_OBU_FRAME_HEADER;
562 ✗ obu->header.obu_has_size_field = 1;
563
564 ✗ fh->frame_type = AV1_FRAME_INTER;
565 ✗ fh->refresh_frame_flags = 1 << ap->slot;
566 ✗ fh->frame_width_minus_1 = base_ctx->surface_width - 1;
567 ✗ fh->frame_height_minus_1 = base_ctx->surface_height - 1;
568 ✗ fh->render_width_minus_1 = fh->frame_width_minus_1;
569 ✗ fh->render_height_minus_1 = fh->frame_height_minus_1;
570
571 ✗ memcpy(fh->loop_filter_ref_deltas, default_loop_filter_ref_deltas,
572 AV1_TOTAL_REFS_PER_FRAME * sizeof(int8_t));
573
574 ✗ obu = &enc->tail_obu;
575 ✗ fh = &obu->obu.frame_header;
576
577 /** tail frame header */
578 ✗ memset(obu, 0, sizeof(*obu));
579 ✗ obu->header.obu_type = AV1_OBU_FRAME_HEADER;
580 ✗ obu->header.obu_has_size_field = 1;
581
582 ✗ fh->show_existing_frame = 1;
583 ✗ fh->frame_to_show_map_idx = ap->slot != 0;
584 ✗ fh->frame_type = AV1_FRAME_INTER;
585 ✗ fh->frame_width_minus_1 = base_ctx->surface_width - 1;
586 ✗ fh->frame_height_minus_1 = base_ctx->surface_height - 1;
587 ✗ fh->render_width_minus_1 = fh->frame_width_minus_1;
588 ✗ fh->render_height_minus_1 = fh->frame_height_minus_1;
589 }
590
591 ✗ return 0;
592 }
593
594 ✗ static int init_profile(AVCodecContext *avctx,
595 VkVideoProfileInfoKHR *profile, void *pnext)
596 {
597 VkResult ret;
598 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
599 ✗ FFVulkanEncodeContext *ctx = &enc->common;
600 ✗ FFVulkanContext *s = &ctx->s;
601 ✗ FFVulkanFunctions *vk = &ctx->s.vkfn;
602
603 ✗ VkVideoEncodeAV1CapabilitiesKHR av1_caps = {
604 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR,
605 };
606 ✗ VkVideoEncodeCapabilitiesKHR enc_caps = {
607 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR,
608 .pNext = &av1_caps,
609 };
610 ✗ VkVideoCapabilitiesKHR caps = {
611 .sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
612 .pNext = &enc_caps,
613 };
614
615 /* In order of preference */
616 ✗ int last_supported = AV_PROFILE_UNKNOWN;
617 static const int known_profiles[] = {
618 AV_PROFILE_AV1_MAIN,
619 AV_PROFILE_AV1_HIGH,
620 AV_PROFILE_AV1_PROFESSIONAL,
621 };
622 ✗ int nb_profiles = FF_ARRAY_ELEMS(known_profiles);
623
624 ✗ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->frames->sw_format);
625
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 5 not taken.
 ✗ if (!desc)
626 ✗ return AVERROR(EINVAL);
627
628
0/2
✗ Branch 5 → 6 not taken.
✗ Branch 5 → 7 not taken.
 ✗ if (s->frames->sw_format == AV_PIX_FMT_NV12 ||
629
0/2
✗ Branch 6 → 7 not taken.
✗ Branch 6 → 8 not taken.
 ✗ s->frames->sw_format == AV_PIX_FMT_P010)
630 ✗ nb_profiles = 1;
631
632 ✗ enc->profile = (VkVideoEncodeAV1ProfileInfoKHR) {
633 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR,
634 .pNext = pnext,
635 ✗ .stdProfile = ff_vk_av1_profile_to_vk(avctx->profile),
636 };
637 ✗ profile->pNext = &enc->profile;
638
639 /* User has explicitly specified a profile. */
640
0/2
✗ Branch 9 → 10 not taken.
✗ Branch 9 → 11 not taken.
 ✗ if (avctx->profile != AV_PROFILE_UNKNOWN)
641 ✗ return 0;
642
643 ✗ av_log(avctx, AV_LOG_DEBUG, "Supported profiles:\n");
644
0/2
✗ Branch 20 → 13 not taken.
✗ Branch 20 → 21 not taken.
 ✗ for (int i = 0; i < nb_profiles; i++) {
645 ✗ enc->profile.stdProfile = ff_vk_av1_profile_to_vk(known_profiles[i]);
646 ✗ ret = vk->GetPhysicalDeviceVideoCapabilitiesKHR(s->hwctx->phys_dev,
647 profile,
648 &caps);
649
0/2
✗ Branch 15 → 16 not taken.
✗ Branch 15 → 19 not taken.
 ✗ if (ret == VK_SUCCESS) {
650 ✗ av_log(avctx, AV_LOG_DEBUG, " %s\n",
651 ✗ avcodec_profile_name(avctx->codec_id, known_profiles[i]));
652 ✗ last_supported = known_profiles[i];
653 }
654 }
655
656
0/2
✗ Branch 21 → 22 not taken.
✗ Branch 21 → 24 not taken.
 ✗ if (last_supported == AV_PROFILE_UNKNOWN) {
657 ✗ av_log(avctx, AV_LOG_ERROR, "No supported profiles for given format\n");
658 ✗ return AVERROR(ENOTSUP);
659 }
660
661 ✗ enc->profile.stdProfile = ff_vk_av1_profile_to_vk(last_supported);
662 ✗ av_log(avctx, AV_LOG_VERBOSE, "Using profile %s\n",
663 avcodec_profile_name(avctx->codec_id, last_supported));
664 ✗ avctx->profile = last_supported;
665
666 ✗ return 0;
667 }
668
669 ✗ static int init_enc_options(AVCodecContext *avctx)
670 {
671 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
672
673
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
 ✗ if (avctx->rc_buffer_size)
674 ✗ enc->hrd_buffer_size = avctx->rc_buffer_size;
675
0/2
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
 ✗ else if (avctx->rc_max_rate > 0)
676 ✗ enc->hrd_buffer_size = avctx->rc_max_rate;
677 else
678 ✗ enc->hrd_buffer_size = avctx->bit_rate;
679
680
0/2
✗ Branch 7 → 8 not taken.
✗ Branch 7 → 12 not taken.
 ✗ if (avctx->rc_initial_buffer_occupancy) {
681
0/2
✗ Branch 8 → 9 not taken.
✗ Branch 8 → 11 not taken.
 ✗ if (avctx->rc_initial_buffer_occupancy > enc->hrd_buffer_size) {
682 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid RC buffer settings: "
683 "must have initial buffer size (%d) <= "
684 "buffer size (%"PRId64").\n",
685 avctx->rc_initial_buffer_occupancy, enc->hrd_buffer_size);
686 ✗ return AVERROR(EINVAL);
687 }
688 ✗ enc->initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
689 } else {
690 ✗ enc->initial_buffer_fullness = enc->hrd_buffer_size * 3 / 4;
691 }
692
693
0/2
✗ Branch 13 → 14 not taken.
✗ Branch 13 → 20 not taken.
 ✗ if (enc->common.opts.rc_mode == VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR) {
694 ✗ enc->q_idx_p = av_clip(enc->common.opts.qp,
695 ✗ enc->caps.minQIndex, enc->caps.maxQIndex);
696
0/2
✗ Branch 14 → 15 not taken.
✗ Branch 14 → 16 not taken.
 ✗ if (fabs(avctx->i_quant_factor) > 0.0)
697 ✗ enc->q_idx_idr =
698 ✗ av_clip((fabs(avctx->i_quant_factor) * enc->q_idx_p +
699 ✗ avctx->i_quant_offset) + 0.5,
700 0, 255);
701 else
702 ✗ enc->q_idx_idr = enc->q_idx_p;
703
704
0/2
✗ Branch 17 → 18 not taken.
✗ Branch 17 → 19 not taken.
 ✗ if (fabs(avctx->b_quant_factor) > 0.0)
705 ✗ enc->q_idx_b =
706 ✗ av_clip((fabs(avctx->b_quant_factor) * enc->q_idx_p +
707 ✗ avctx->b_quant_offset) + 0.5,
708 0, 255);
709 else
710 ✗ enc->q_idx_b = enc->q_idx_p;
711 } else {
712 /** Arbitrary value */
713 ✗ enc->q_idx_idr = enc->q_idx_p = enc->q_idx_b = 128;
714 }
715
716 ✗ return 0;
717 }
718
719 ✗ static av_cold int init_sequence_headers(AVCodecContext *avctx)
720 {
721 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
722 ✗ FFVulkanEncodeContext *ctx = &enc->common;
723 ✗ FFVulkanContext *s = &ctx->s;
724 ✗ FFHWBaseEncodeContext *base_ctx = &ctx->base;
725
726 ✗ AV1RawOBU *seq_obu = &enc->seq_hdr_obu;
727 ✗ AV1RawSequenceHeader *seq = &seq_obu->obu.sequence_header;
728
729 ✗ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->frames->sw_format);
730
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 5 not taken.
 ✗ if (!desc)
731 ✗ return AVERROR(EINVAL);
732
733 ✗ enc->seq_tier = enc->common.opts.tier;
734
735
0/2
✗ Branch 5 → 6 not taken.
✗ Branch 5 → 16 not taken.
 ✗ if (avctx->level == AV_LEVEL_UNKNOWN) {
736 const AV1LevelDescriptor *level;
737 ✗ float framerate = 0.0;
738
739
0/4
✗ Branch 6 → 7 not taken.
✗ Branch 6 → 10 not taken.
✗ Branch 7 → 8 not taken.
✗ Branch 7 → 10 not taken.
 ✗ if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
740 ✗ framerate = av_q2d(avctx->framerate);
741
742 ✗ level = ff_av1_guess_level(avctx->bit_rate, enc->seq_tier,
743 base_ctx->surface_width, base_ctx->surface_height,
744 ✗ enc->tile_rows * enc->tile_cols,
745 enc->tile_cols, framerate);
746
0/2
✗ Branch 11 → 12 not taken.
✗ Branch 11 → 14 not taken.
 ✗ if (level) {
747 ✗ av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
748 ✗ enc->seq_level_idx = level->level_idx;
749 } else {
750 ✗ av_log(avctx, AV_LOG_VERBOSE, "Stream will not conform to "
751 "any normal level, using level 7.3 by default.\n");
752 ✗ enc->seq_level_idx = STD_VIDEO_AV1_LEVEL_7_3;
753 ✗ enc->seq_tier = 1;
754 }
755 } else {
756 ✗ enc->seq_level_idx = avctx->level;
757 }
758
759 ✗ seq_obu->header.obu_type = AV1_OBU_SEQUENCE_HEADER;
760 ✗ *seq = (AV1RawSequenceHeader) {
761 ✗ .seq_profile = avctx->profile,
762 .seq_force_integer_mv = seq->seq_force_screen_content_tools ?
763 AV1_SELECT_SCREEN_CONTENT_TOOLS :
764 AV1_SELECT_INTEGER_MV,
765 ✗ .frame_width_bits_minus_1 = av_log2(base_ctx->surface_width),
766 ✗ .frame_height_bits_minus_1 = av_log2(base_ctx->surface_height),
767 ✗ .max_frame_width_minus_1 = base_ctx->surface_width - 1,
768 ✗ .max_frame_height_minus_1 = base_ctx->surface_height - 1,
769 .enable_order_hint = 1,
770 ✗ .order_hint_bits_minus_1 = av_clip_intp2(av_log2(ctx->base.gop_size), 3),
771 ✗ .use_128x128_superblock = !!(enc->caps.superblockSizes & VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR),
772 .color_config = (AV1RawColorConfig) {
773 ✗ .high_bitdepth = desc->comp[0].depth > 8,
774 ✗ .color_primaries = avctx->color_primaries,
775 ✗ .transfer_characteristics = avctx->color_trc,
776 ✗ .matrix_coefficients = avctx->colorspace,
777 ✗ .color_description_present_flag = (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
778
0/2
✗ Branch 18 → 19 not taken.
✗ Branch 18 → 20 not taken.
 ✗ avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
779
0/2
✗ Branch 19 → 20 not taken.
✗ Branch 19 → 21 not taken.
 ✗ avctx->colorspace != AVCOL_SPC_UNSPECIFIED),
780 ✗ .subsampling_x = desc->log2_chroma_w,
781 ✗ .subsampling_y = desc->log2_chroma_h,
782
0/2
✗ Branch 22 → 23 not taken.
✗ Branch 22 → 26 not taken.
 ✗ .chroma_sample_position = avctx->chroma_sample_location == AVCHROMA_LOC_LEFT ?
783 AV1_CSP_VERTICAL :
784
0/2
✗ Branch 23 → 24 not taken.
✗ Branch 23 → 25 not taken.
 ✗ avctx->chroma_sample_location == AVCHROMA_LOC_TOPLEFT ?
785 AV1_CSP_COLOCATED :
786 AV1_CSP_UNKNOWN,
787 },
788
789 /* Operating point */
790 ✗ .seq_tier = { enc->seq_tier },
791 ✗ .seq_level_idx = { enc->seq_level_idx },
792 ✗ .decoder_buffer_delay = { base_ctx->decode_delay },
793
0/2
✗ Branch 17 → 18 not taken.
✗ Branch 17 → 20 not taken.
 ✗ .encoder_buffer_delay = { base_ctx->output_delay },
794 .operating_points_cnt_minus_1 = 1 - 1,
795 };
796
797 ✗ return 0;
798 }
799
800 typedef struct VulkanAV1Units {
801 StdVideoAV1SequenceHeader seq_hdr;
802 StdVideoAV1TimingInfo timing_info;
803 StdVideoAV1ColorConfig color_config;
804
805 StdVideoEncodeAV1DecoderModelInfo decoder_model;
806 StdVideoEncodeAV1OperatingPointInfo operating_points[AV1_MAX_OPERATING_POINTS];
807 int nb_operating_points;
808 } VulkanAV1Units;
809
810 ✗ static av_cold int base_unit_to_vk(AVCodecContext *avctx, VulkanAV1Units *vk_units)
811 {
812 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
813
814 ✗ AV1RawOBU *seq_obu = &enc->seq_hdr_obu;
815 ✗ AV1RawSequenceHeader *seq = &seq_obu->obu.sequence_header;
816
817 ✗ StdVideoAV1SequenceHeader *seq_hdr = &vk_units->seq_hdr;
818 ✗ StdVideoAV1TimingInfo *timing_info = &vk_units->timing_info;
819 ✗ StdVideoAV1ColorConfig *color_config = &vk_units->color_config;
820
821 ✗ StdVideoEncodeAV1OperatingPointInfo *operating_points = vk_units->operating_points;
822
823 ✗ *timing_info = (StdVideoAV1TimingInfo) {
824 .flags = (StdVideoAV1TimingInfoFlags) {
825 ✗ .equal_picture_interval = seq->timing_info.equal_picture_interval,
826 },
827 ✗ .num_units_in_display_tick = seq->timing_info.num_units_in_display_tick,
828 ✗ .time_scale = seq->timing_info.time_scale,
829 ✗ .num_ticks_per_picture_minus_1 = seq->timing_info.num_ticks_per_picture_minus_1,
830 };
831
832 ✗ *color_config = (StdVideoAV1ColorConfig) {
833 .flags = (StdVideoAV1ColorConfigFlags) {
834 ✗ .mono_chrome = seq->color_config.mono_chrome,
835 ✗ .color_range = seq->color_config.color_range,
836 ✗ .separate_uv_delta_q = seq->color_config.separate_uv_delta_q,
837 },
838
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 6 not taken.
 ✗ .BitDepth = seq->color_config.twelve_bit ? 12 :
839
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 5 not taken.
 ✗ seq->color_config.high_bitdepth ? 10 : 8,
840 ✗ .subsampling_x = seq->color_config.subsampling_x,
841 ✗ .subsampling_y = seq->color_config.subsampling_y,
842 ✗ .color_primaries = seq->color_config.color_primaries,
843 ✗ .transfer_characteristics = seq->color_config.transfer_characteristics,
844 ✗ .matrix_coefficients = seq->color_config.matrix_coefficients,
845 };
846
847 ✗ *seq_hdr = (StdVideoAV1SequenceHeader) {
848 .flags = (StdVideoAV1SequenceHeaderFlags) {
849 ✗ .still_picture = seq->still_picture,
850 ✗ .reduced_still_picture_header = seq->reduced_still_picture_header,
851 ✗ .use_128x128_superblock = seq->use_128x128_superblock,
852 ✗ .enable_filter_intra = seq->enable_filter_intra,
853 ✗ .enable_intra_edge_filter = seq->enable_intra_edge_filter,
854 ✗ .enable_interintra_compound = seq->enable_interintra_compound,
855 ✗ .enable_masked_compound = seq->enable_masked_compound,
856 ✗ .enable_warped_motion = seq->enable_warped_motion,
857 ✗ .enable_dual_filter = seq->enable_dual_filter,
858 ✗ .enable_order_hint = seq->enable_order_hint,
859 ✗ .enable_jnt_comp = seq->enable_jnt_comp,
860 ✗ .enable_ref_frame_mvs = seq->enable_ref_frame_mvs,
861 ✗ .frame_id_numbers_present_flag = seq->frame_id_numbers_present_flag,
862 ✗ .enable_superres = seq->enable_superres,
863 ✗ .enable_cdef = seq->enable_cdef,
864 ✗ .enable_restoration = seq->enable_restoration,
865 ✗ .film_grain_params_present = seq->film_grain_params_present,
866 ✗ .timing_info_present_flag = seq->timing_info_present_flag,
867 ✗ .initial_display_delay_present_flag = seq->initial_display_delay_present_flag,
868 },
869 ✗ .seq_profile = seq->seq_profile,
870 ✗ .frame_width_bits_minus_1 = seq->frame_width_bits_minus_1,
871 ✗ .frame_height_bits_minus_1 = seq->frame_height_bits_minus_1,
872 ✗ .max_frame_width_minus_1 = seq->max_frame_width_minus_1,
873 ✗ .max_frame_height_minus_1 = seq->max_frame_height_minus_1,
874 ✗ .delta_frame_id_length_minus_2 = seq->delta_frame_id_length_minus_2,
875 ✗ .additional_frame_id_length_minus_1 = seq->additional_frame_id_length_minus_1,
876 ✗ .order_hint_bits_minus_1 = seq->order_hint_bits_minus_1,
877 ✗ .seq_force_integer_mv = seq->seq_force_integer_mv,
878 ✗ .seq_force_screen_content_tools = seq->seq_force_screen_content_tools,
879 .pTimingInfo = timing_info,
880 .pColorConfig = color_config,
881 };
882
883
0/2
✗ Branch 9 → 8 not taken.
✗ Branch 9 → 10 not taken.
 ✗ for (int i = 0; i <= seq->operating_points_cnt_minus_1; i++) {
884 ✗ operating_points[i] = (StdVideoEncodeAV1OperatingPointInfo) {
885 .flags = (StdVideoEncodeAV1OperatingPointInfoFlags) {
886 ✗ .decoder_model_present_for_this_op = seq->decoder_model_present_for_this_op[i],
887 ✗ .low_delay_mode_flag = seq->low_delay_mode_flag[i],
888 ✗ .initial_display_delay_present_for_this_op = seq->initial_display_delay_present_for_this_op[i],
889 /* Reserved */
890 },
891 ✗ .operating_point_idc = seq->operating_point_idc[i],
892 ✗ .seq_level_idx = seq->seq_level_idx[i],
893 ✗ .seq_tier = seq->seq_tier[i],
894 ✗ .decoder_buffer_delay = seq->decoder_buffer_delay[i],
895 ✗ .encoder_buffer_delay = seq->encoder_buffer_delay[i],
896 ✗ .initial_display_delay_minus_1 = seq->initial_display_delay_minus_1[i],
897 };
898 }
899 ✗ vk_units->nb_operating_points = seq->operating_points_cnt_minus_1 + 1;
900
901 ✗ return 0;
902 }
903
904 ✗ static int create_session_params(AVCodecContext *avctx)
905 {
906 int err;
907 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
908 ✗ FFVulkanEncodeContext *ctx = &enc->common;
909 ✗ FFVulkanContext *s = &ctx->s;
910 ✗ FFVulkanFunctions *vk = &ctx->s.vkfn;
911
912 ✗ VulkanAV1Units vk_units = { 0 };
913
914 VkVideoEncodeAV1SessionParametersCreateInfoKHR av1_params;
915
916 /* Convert it to Vulkan */
917 ✗ err = base_unit_to_vk(avctx, &vk_units);
918
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 7 not taken.
 ✗ if (err < 0) {
919 ✗ av_log(avctx, AV_LOG_ERROR, "Unable to convert sequence header to Vulkan: %s\n",
920 ✗ av_err2str(err));
921 ✗ return err;
922 }
923
924 /* Destroy the session params */
925
0/2
✗ Branch 7 → 8 not taken.
✗ Branch 7 → 9 not taken.
 ✗ if (ctx->session_params)
926 ✗ vk->DestroyVideoSessionParametersKHR(s->hwctx->act_dev,
927 ctx->session_params,
928 ✗ s->hwctx->alloc);
929
930 ✗ av1_params = (VkVideoEncodeAV1SessionParametersCreateInfoKHR) {
931 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR,
932 .pStdSequenceHeader = &vk_units.seq_hdr,
933 .pStdDecoderModelInfo = &vk_units.decoder_model,
934 .pStdOperatingPoints = vk_units.operating_points,
935 ✗ .stdOperatingPointCount = vk_units.nb_operating_points,
936 };
937
938 ✗ return ff_vulkan_encode_create_session_params(avctx, ctx, &av1_params);
939 }
940
941 ✗ static int parse_feedback_units(AVCodecContext *avctx,
942 const uint8_t *data, size_t size)
943 {
944 int err;
945 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
946 ✗ AV1RawOBU *seq_obu = &enc->seq_hdr_obu;
947 ✗ AV1RawSequenceHeader *seq = &seq_obu->obu.sequence_header;
948
949 CodedBitstreamContext *cbs;
950 ✗ CodedBitstreamFragment obu = { 0 };
951
952 ✗ err = ff_cbs_init(&cbs, AV_CODEC_ID_AV1, avctx);
953
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 5 not taken.
 ✗ if (err < 0)
954 ✗ return err;
955
956 ✗ err = ff_cbs_read(cbs, &obu, NULL, data, size);
957
0/2
✗ Branch 6 → 7 not taken.
✗ Branch 6 → 10 not taken.
 ✗ if (err < 0) {
958 ✗ av_log(avctx, AV_LOG_ERROR, "Unable to parse feedback units, bad drivers: %s\n",
959 ✗ av_err2str(err));
960 ✗ return err;
961 }
962
963 /* If PPS has an override, just copy it entirely. */
964
0/2
✗ Branch 14 → 11 not taken.
✗ Branch 14 → 15 not taken.
 ✗ for (int i = 0; i < obu.nb_units; i++) {
965
0/2
✗ Branch 11 → 12 not taken.
✗ Branch 11 → 13 not taken.
 ✗ if (obu.units[i].type == AV1_OBU_SEQUENCE_HEADER) {
966 ✗ AV1RawOBU *f_seq_obu = obu.units[i].content;
967 ✗ AV1RawSequenceHeader *f_seq = &f_seq_obu->obu.sequence_header;
968 ✗ seq->frame_width_bits_minus_1 = f_seq->frame_width_bits_minus_1;
969 ✗ seq->frame_height_bits_minus_1 = f_seq->frame_height_bits_minus_1;
970 ✗ seq->max_frame_width_minus_1 = f_seq->max_frame_width_minus_1;
971 ✗ seq->max_frame_height_minus_1 = f_seq->max_frame_height_minus_1;
972 ✗ seq->seq_choose_screen_content_tools = f_seq->seq_choose_screen_content_tools;
973 ✗ seq->seq_force_screen_content_tools = f_seq->seq_force_screen_content_tools;
974 ✗ seq->seq_choose_integer_mv = f_seq->seq_choose_integer_mv;
975 ✗ seq->seq_force_integer_mv = f_seq->seq_force_integer_mv;
976 }
977 }
978
979 ✗ ff_cbs_fragment_free(&obu);
980 ✗ ff_cbs_close(&cbs);
981
982 ✗ return 0;
983 }
984
985 ✗ static int init_base_units(AVCodecContext *avctx)
986 {
987 int err;
988 VkResult ret;
989 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
990 ✗ FFVulkanEncodeContext *ctx = &enc->common;
991 ✗ FFVulkanContext *s = &ctx->s;
992 ✗ FFVulkanFunctions *vk = &ctx->s.vkfn;
993
994 VkVideoEncodeSessionParametersGetInfoKHR params_info;
995 VkVideoEncodeSessionParametersFeedbackInfoKHR params_feedback;
996
997 ✗ void *data = NULL;
998 ✗ size_t data_size = 0;
999
1000 /* Generate SPS/PPS unit info */
1001 ✗ err = init_sequence_headers(avctx);
1002
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 7 not taken.
 ✗ if (err < 0) {
1003 ✗ av_log(avctx, AV_LOG_ERROR, "Unable to initialize sequence header: %s\n",
1004 ✗ av_err2str(err));
1005 ✗ return err;
1006 }
1007
1008 /* Create session parameters from them */
1009 ✗ err = create_session_params(avctx);
1010
0/2
✗ Branch 8 → 9 not taken.
✗ Branch 8 → 10 not taken.
 ✗ if (err < 0)
1011 ✗ return err;
1012
1013 ✗ params_info = (VkVideoEncodeSessionParametersGetInfoKHR) {
1014 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR,
1015 ✗ .videoSessionParameters = ctx->session_params,
1016 };
1017 ✗ params_feedback = (VkVideoEncodeSessionParametersFeedbackInfoKHR) {
1018 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR,
1019 };
1020
1021 ✗ ret = vk->GetEncodedVideoSessionParametersKHR(s->hwctx->act_dev, &params_info,
1022 &params_feedback,
1023 &data_size, data);
1024
0/4
✗ Branch 11 → 12 not taken.
✗ Branch 11 → 14 not taken.
✗ Branch 12 → 13 not taken.
✗ Branch 12 → 18 not taken.
 ✗ if (ret == VK_INCOMPLETE ||
1025
0/2
✗ Branch 13 → 14 not taken.
✗ Branch 13 → 18 not taken.
 ✗ (ret == VK_SUCCESS) && (data_size > 0)) {
1026 ✗ data = av_mallocz(data_size);
1027
0/2
✗ Branch 15 → 16 not taken.
✗ Branch 15 → 17 not taken.
 ✗ if (!data)
1028 ✗ return AVERROR(ENOMEM);
1029 } else {
1030 ✗ av_log(avctx, AV_LOG_ERROR, "Unable to get feedback for AV1 sequence header = %zu\n",
1031 data_size);
1032 ✗ return AVERROR_EXTERNAL;
1033 }
1034
1035 ✗ ret = vk->GetEncodedVideoSessionParametersKHR(s->hwctx->act_dev, &params_info,
1036 &params_feedback,
1037 &data_size, data);
1038
0/2
✗ Branch 21 → 22 not taken.
✗ Branch 21 → 24 not taken.
 ✗ if (ret != VK_SUCCESS) {
1039 ✗ av_log(avctx, AV_LOG_ERROR, "Error writing feedback units\n");
1040 ✗ err = AVERROR_EXTERNAL;
1041 ✗ goto end;
1042 }
1043
1044 ✗ av_log(avctx, AV_LOG_VERBOSE, "Feedback units written, overrides: %i\n",
1045 params_feedback.hasOverrides);
1046
1047 ✗ params_feedback.hasOverrides = 1;
1048
1049 /* No need to sync any overrides */
1050 ✗ err = 0;
1051
0/2
✗ Branch 25 → 26 not taken.
✗ Branch 25 → 27 not taken.
 ✗ if (!params_feedback.hasOverrides)
1052 ✗ goto end;
1053
1054 /* Parse back tne units and override */
1055 ✗ err = parse_feedback_units(avctx, data, data_size);
1056
0/2
✗ Branch 28 → 29 not taken.
✗ Branch 28 → 30 not taken.
 ✗ if (err < 0)
1057 ✗ goto end;
1058
1059 /* Create final session parameters */
1060 ✗ err = create_session_params(avctx);
1061
1062 ✗ end:
1063 ✗ av_free(data);
1064 ✗ return err;
1065 }
1066
1067 ✗ static int vulkan_encode_av1_add_obu(AVCodecContext *avctx,
1068 CodedBitstreamFragment *au,
1069 uint8_t type, void *obu_unit)
1070 {
1071 int err;
1072
1073 ✗ err = ff_cbs_insert_unit_content(au, -1,
1074 type, obu_unit, NULL);
1075
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 6 not taken.
 ✗ if (err < 0) {
1076 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to add OBU unit: "
1077 "type = %d.\n", type);
1078 ✗ return err;
1079 }
1080
1081 ✗ return err;
1082 }
1083
1084 ✗ static int vulkan_encode_av1_write_obu(AVCodecContext *avctx,
1085 uint8_t *data, size_t *data_len,
1086 CodedBitstreamFragment *obu)
1087 {
1088 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
1089 int ret;
1090
1091 ✗ ret = ff_cbs_write_fragment_data(enc->cbs, obu);
1092
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 6 not taken.
 ✗ if (ret < 0) {
1093 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
1094 ✗ return ret;
1095 }
1096
1097 ✗ memcpy(data, obu->data, obu->data_size);
1098 ✗ *data_len = obu->data_size;
1099
1100 ✗ return 0;
1101 }
1102
1103 ✗ static int write_sequence_header(AVCodecContext *avctx,
1104 FFHWBaseEncodePicture *base_pic,
1105 uint8_t *data, size_t *data_len)
1106 {
1107 int err;
1108 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
1109 ✗ CodedBitstreamFragment *obu = &enc->current_access_unit;
1110
1111 ✗ err = vulkan_encode_av1_add_obu(avctx, obu,
1112 ✗ AV1_OBU_SEQUENCE_HEADER, &enc->seq_hdr_obu);
1113
0/2
✗ Branch 3 → 4 not taken.
✗ Branch 3 → 5 not taken.
 ✗ if (err < 0)
1114 ✗ goto fail;
1115
1116 ✗ err = vulkan_encode_av1_write_obu(avctx, data, data_len, obu);
1117
1118 ✗ fail:
1119 ✗ ff_cbs_fragment_reset(obu);
1120 ✗ return err;
1121 }
1122
1123 ✗ static int write_extra_headers(AVCodecContext *avctx,
1124 FFHWBaseEncodePicture *base_pic,
1125 uint8_t *data, size_t *data_len)
1126 {
1127 int err;
1128 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
1129 ✗ VulkanEncodeAV1Picture *ap = base_pic->codec_priv;
1130 ✗ FFVulkanEncodePicture *vp = base_pic->priv;
1131 ✗ CodedBitstreamFragment *obu = &enc->current_access_unit;
1132
1133
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 16 not taken.
 ✗ if (vp->non_independent_frame) {
1134 ✗ err = vulkan_encode_av1_add_obu(avctx, obu, AV1_OBU_FRAME_HEADER, &enc->hidden_obu);
1135
0/2
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
 ✗ if (err < 0)
1136 ✗ goto fail;
1137
1138 // Only for tracking ref frame in context, not to be output
1139 ✗ err = ff_cbs_write_fragment_data(enc->cbs, obu);
1140
0/2
✗ Branch 7 → 8 not taken.
✗ Branch 7 → 9 not taken.
 ✗ if (err < 0)
1141 ✗ goto fail;
1142
1143 ✗ ff_cbs_fragment_reset(obu);
1144 ✗ ((CodedBitstreamAV1Context *)enc->cbs->priv_data)->seen_frame_header = 0;
1145
1146 ✗ err = vulkan_encode_av1_add_obu(avctx, obu, AV1_OBU_FRAME_HEADER, &enc->tail_obu);
1147
0/2
✗ Branch 11 → 12 not taken.
✗ Branch 11 → 13 not taken.
 ✗ if (err < 0)
1148 ✗ goto fail;
1149
1150 ✗ err = vulkan_encode_av1_write_obu(avctx, vp->tail_data, &vp->tail_size, obu);
1151
0/2
✗ Branch 14 → 15 not taken.
✗ Branch 14 → 16 not taken.
 ✗ if (err < 0)
1152 ✗ goto fail;
1153 }
1154
1155
0/2
✗ Branch 16 → 17 not taken.
✗ Branch 16 → 20 not taken.
 ✗ if (ap->units_needed & UNIT_MASTERING_DISPLAY) {
1156 ✗ err = vulkan_encode_av1_add_obu(avctx, obu,
1157 AV1_OBU_METADATA,
1158 ✗ &enc->meta_mastering_obu);
1159
0/2
✗ Branch 18 → 19 not taken.
✗ Branch 18 → 20 not taken.
 ✗ if (err < 0)
1160 ✗ goto fail;
1161 }
1162
1163
0/2
✗ Branch 20 → 21 not taken.
✗ Branch 20 → 24 not taken.
 ✗ if (ap->units_needed & UNIT_CONTENT_LIGHT_LEVEL) {
1164 ✗ err = vulkan_encode_av1_add_obu(avctx, obu,
1165 AV1_OBU_METADATA,
1166 ✗ &enc->meta_cll_obu);
1167
0/2
✗ Branch 22 → 23 not taken.
✗ Branch 22 → 24 not taken.
 ✗ if (err < 0)
1168 ✗ goto fail;
1169 }
1170
1171
0/2
✗ Branch 24 → 25 not taken.
✗ Branch 24 → 28 not taken.
 ✗ if (ap->units_needed) {
1172 ✗ err = vulkan_encode_av1_write_obu(avctx, data, data_len, obu);
1173
0/2
✗ Branch 26 → 27 not taken.
✗ Branch 26 → 29 not taken.
 ✗ if (err < 0)
1174 ✗ goto fail;
1175 } else {
1176 ✗ err = 0;
1177 ✗ *data_len = 0;
1178 }
1179
1180 ✗ fail:
1181 ✗ ff_cbs_fragment_reset(obu);
1182 ✗ return err;
1183 }
1184
1185 ✗ static int write_padding(AVCodecContext *avctx, uint32_t padding,
1186 uint8_t *data, size_t *data_len)
1187 {
1188 int err;
1189 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
1190 ✗ CodedBitstreamFragment *obu = &enc->current_access_unit;
1191
1192 ✗ AV1RawOBU padding_obu = { 0 };
1193 ✗ AV1RawPadding *raw_padding = &padding_obu.obu.padding;
1194
1195
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
 ✗ if (!padding)
1196 ✗ padding = 16;
1197
1198 /* 2 byte header + 1 byte trailing bits */
1199 ✗ padding_obu.header.obu_type = AV1_OBU_PADDING;
1200 ✗ *raw_padding = (AV1RawPadding) {
1201 ✗ .payload = enc->padding_payload,
1202 .payload_size = padding,
1203 };
1204
1205 ✗ err = vulkan_encode_av1_add_obu(avctx, obu, AV1_OBU_PADDING, &padding_obu);
1206
0/2
✗ Branch 5 → 6 not taken.
✗ Branch 5 → 7 not taken.
 ✗ if (err < 0)
1207 ✗ goto fail;
1208
1209 ✗ err = vulkan_encode_av1_write_obu(avctx, data, data_len, obu);
1210 ✗ fail:
1211 ✗ ff_cbs_fragment_reset(obu);
1212 ✗ return err;
1213 }
1214
1215 static const FFVulkanCodec enc_cb = {
1216 .flags = FF_HW_FLAG_B_PICTURES |
1217 FF_HW_FLAG_B_PICTURE_REFERENCES |
1218 VK_ENC_FLAG_NO_DELAY |
1219 FF_HW_FLAG_SLICE_CONTROL,
1220 .picture_priv_data_size = sizeof(VulkanEncodeAV1Picture),
1221 .filler_header_size = 4,
1222 .init_profile = init_profile,
1223 .init_pic_rc = init_pic_rc,
1224 .init_pic_params = init_pic_params,
1225 .write_sequence_headers = write_sequence_header,
1226 .write_extra_headers = write_extra_headers,
1227 .write_filler = write_padding,
1228 };
1229
1230 ✗ static av_cold int vulkan_encode_av1_init(AVCodecContext *avctx)
1231 {
1232 int err;
1233 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
1234 ✗ FFVulkanEncodeContext *ctx = &enc->common;
1235 ✗ FFHWBaseEncodeContext *base_ctx = &ctx->base;
1236 int flags;
1237
1238
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
 ✗ if (avctx->profile == AV_PROFILE_UNKNOWN)
1239 ✗ avctx->profile = enc->common.opts.profile;
1240
0/2
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
 ✗ if (avctx->level == AV_LEVEL_UNKNOWN)
1241 ✗ avctx->level = enc->common.opts.level;
1242
1243 ✗ enc->caps = (VkVideoEncodeAV1CapabilitiesKHR) {
1244 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR,
1245 };
1246
1247 ✗ enc->quality_props = (VkVideoEncodeAV1QualityLevelPropertiesKHR) {
1248 .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR,
1249 };
1250
1251 ✗ err = ff_vulkan_encode_init(avctx, &enc->common,
1252 &ff_vk_enc_av1_desc, &enc_cb,
1253 ✗ &enc->caps, &enc->quality_props);
1254
0/2
✗ Branch 7 → 8 not taken.
✗ Branch 7 → 9 not taken.
 ✗ if (err < 0)
1255 ✗ return err;
1256
1257 ✗ av_log(avctx, AV_LOG_VERBOSE, "AV1 encoder capabilities:\n");
1258 ✗ av_log(avctx, AV_LOG_VERBOSE, " Standard capability flags:\n");
1259 ✗ av_log(avctx, AV_LOG_VERBOSE, " per_rate_control_group_min_max_q_index: %i\n",
1260 ✗ !!(enc->caps.flags & VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR));
1261 ✗ av_log(avctx, AV_LOG_VERBOSE, " generate_obu_extension_header: %i\n",
1262 ✗ !!(enc->caps.flags & VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR));
1263 ✗ av_log(avctx, AV_LOG_VERBOSE, " primary_reference_cdf_only: %i\n",
1264 ✗ !!(enc->caps.flags & VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR));
1265 ✗ av_log(avctx, AV_LOG_VERBOSE, " frame_size_override: %i\n",
1266 ✗ !!(enc->caps.flags & VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR));
1267 ✗ av_log(avctx, AV_LOG_VERBOSE, " motion_vector_scaling: %i\n",
1268 ✗ !!(enc->caps.flags & VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR));
1269 ✗ av_log(avctx, AV_LOG_VERBOSE, " Capabilities:\n");
1270 ✗ av_log(avctx, AV_LOG_VERBOSE, " 64x64 superblocks: %i\n",
1271 ✗ !!(enc->caps.superblockSizes & VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR));
1272 ✗ av_log(avctx, AV_LOG_VERBOSE, " 128x128 superblocks: %i\n",
1273 ✗ !!(enc->caps.superblockSizes & VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR));
1274 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxSingleReferenceCount: %i\n",
1275 enc->caps.maxSingleReferenceCount);
1276 ✗ av_log(avctx, AV_LOG_VERBOSE, " singleReferenceNameMask: 0x%x\n",
1277 enc->caps.singleReferenceNameMask);
1278 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxUnidirectionalCompoundReferenceCount: %i\n",
1279 enc->caps.maxUnidirectionalCompoundReferenceCount);
1280 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxUnidirectionalCompoundGroup1ReferenceCount: %i\n",
1281 enc->caps.maxUnidirectionalCompoundGroup1ReferenceCount);
1282 ✗ av_log(avctx, AV_LOG_VERBOSE, " unidirectionalCompoundReferenceNameMask: 0x%x\n",
1283 enc->caps.unidirectionalCompoundReferenceNameMask);
1284 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxBidirectionalCompoundReferenceCount: %i\n",
1285 enc->caps.maxBidirectionalCompoundReferenceCount);
1286 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxBidirectionalCompoundGroup1ReferenceCount: %i\n",
1287 enc->caps.maxBidirectionalCompoundGroup1ReferenceCount);
1288 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxBidirectionalCompoundGroup2ReferenceCount: %i\n",
1289 enc->caps.maxBidirectionalCompoundGroup2ReferenceCount);
1290 ✗ av_log(avctx, AV_LOG_VERBOSE, " bidirectionalCompoundReferenceNameMask: 0x%x\n",
1291 enc->caps.bidirectionalCompoundReferenceNameMask);
1292 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxTemporalLayerCount: %i\n",
1293 enc->caps.maxTemporalLayerCount);
1294 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxSpatialLayerCount: %i\n",
1295 enc->caps.maxSpatialLayerCount);
1296 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxOperatingPoints: %i\n",
1297 enc->caps.maxOperatingPoints);
1298 ✗ av_log(avctx, AV_LOG_VERBOSE, " min/max Qindex: [%i, %i]\n",
1299 enc->caps.minQIndex, enc->caps.maxQIndex);
1300 ✗ av_log(avctx, AV_LOG_VERBOSE, " prefersGopRemainingFrames: %i\n",
1301 enc->caps.prefersGopRemainingFrames);
1302 ✗ av_log(avctx, AV_LOG_VERBOSE, " requiresGopRemainingFrames: %i\n",
1303 enc->caps.requiresGopRemainingFrames);
1304 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxLevel: %i\n",
1305 ✗ enc->caps.maxLevel);
1306 ✗ av_log(avctx, AV_LOG_VERBOSE, " codedPictureAlignment: %ix%i\n",
1307 enc->caps.codedPictureAlignment.width, enc->caps.codedPictureAlignment.height);
1308 ✗ av_log(avctx, AV_LOG_VERBOSE, " maxTiles: %ix%i\n",
1309 enc->caps.maxTiles.width, enc->caps.maxTiles.height);
1310 ✗ av_log(avctx, AV_LOG_VERBOSE, " Tile size: %ix%i to %ix%i\n",
1311 enc->caps.minTileSize.width, enc->caps.minTileSize.height,
1312 enc->caps.maxTileSize.width, enc->caps.maxTileSize.height);
1313
1314 ✗ err = init_enc_options(avctx);
1315
0/2
✗ Branch 39 → 40 not taken.
✗ Branch 39 → 41 not taken.
 ✗ if (err < 0)
1316 ✗ return err;
1317
1318 ✗ flags = ctx->codec->flags;
1319 ✗ err = ff_hw_base_init_gop_structure(base_ctx, avctx,
1320 ctx->caps.maxDpbSlots,
1321 enc->caps.maxBidirectionalCompoundReferenceCount,
1322 flags, 0);
1323
0/2
✗ Branch 42 → 43 not taken.
✗ Branch 42 → 44 not taken.
 ✗ if (err < 0)
1324 ✗ return err;
1325
1326 ✗ base_ctx->output_delay = base_ctx->b_per_p;
1327 ✗ base_ctx->decode_delay = base_ctx->max_b_depth;
1328
1329 /* Create units and session parameters */
1330 ✗ err = init_base_units(avctx);
1331
0/2
✗ Branch 45 → 46 not taken.
✗ Branch 45 → 47 not taken.
 ✗ if (err < 0)
1332 ✗ return err;
1333
1334 /* Init CBS */
1335 ✗ err = ff_cbs_init(&enc->cbs, AV_CODEC_ID_AV1, avctx);
1336
0/2
✗ Branch 48 → 49 not taken.
✗ Branch 48 → 50 not taken.
 ✗ if (err < 0)
1337 ✗ return err;
1338
1339
0/2
✗ Branch 50 → 51 not taken.
✗ Branch 50 → 60 not taken.
 ✗ if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1340 uint8_t data[4096];
1341 ✗ size_t data_len = sizeof(data);
1342
1343 ✗ err = write_sequence_header(avctx, NULL, data, &data_len);
1344
0/2
✗ Branch 52 → 53 not taken.
✗ Branch 52 → 55 not taken.
 ✗ if (err < 0) {
1345 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to write sequence header "
1346 "for extradata: %d.\n", err);
1347 ✗ return err;
1348 } else {
1349 ✗ avctx->extradata_size = data_len;
1350 ✗ avctx->extradata = av_mallocz(avctx->extradata_size +
1351 AV_INPUT_BUFFER_PADDING_SIZE);
1352
0/2
✗ Branch 56 → 57 not taken.
✗ Branch 56 → 58 not taken.
 ✗ if (!avctx->extradata) {
1353 ✗ err = AVERROR(ENOMEM);
1354 ✗ return err;
1355 }
1356 ✗ memcpy(avctx->extradata, data, avctx->extradata_size);
1357 }
1358 }
1359
1360 ✗ enc->padding_payload = av_mallocz(2*ctx->caps.minBitstreamBufferOffsetAlignment);
1361
0/2
✗ Branch 61 → 62 not taken.
✗ Branch 61 → 63 not taken.
 ✗ if (!enc->padding_payload)
1362 ✗ return AVERROR(ENOMEM);
1363
1364 ✗ memset(enc->padding_payload, 0xaa, 2*ctx->caps.minBitstreamBufferOffsetAlignment);
1365
1366 ✗ return 0;
1367 }
1368
1369 ✗ static av_cold int vulkan_encode_av1_close(AVCodecContext *avctx)
1370 {
1371 ✗ VulkanEncodeAV1Context *enc = avctx->priv_data;
1372
1373 ✗ ff_cbs_fragment_free(&enc->current_access_unit);
1374 ✗ ff_cbs_close(&enc->cbs);
1375
1376 ✗ av_free(enc->padding_payload);
1377 ✗ ff_vulkan_encode_uninit(&enc->common);
1378 ✗ return 0;
1379 }
1380
1381 #define OFFSET(x) offsetof(VulkanEncodeAV1Context, x)
1382 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1383 static const AVOption vulkan_encode_av1_options[] = {
1384 HW_BASE_ENCODE_COMMON_OPTIONS,
1385 VULKAN_ENCODE_COMMON_OPTIONS,
1386
1387 { "profile", "Set profile",
1388 OFFSET(common.opts.profile), AV_OPT_TYPE_INT,
1389 { .i64 = AV_PROFILE_UNKNOWN }, AV_PROFILE_UNKNOWN, 0xffff, FLAGS, .unit = "profile" },
1390
1391 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1392 { .i64 = value }, 0, 0, FLAGS, .unit = "profile"
1393 { PROFILE("main", AV_PROFILE_AV1_MAIN) },
1394 { PROFILE("high", AV_PROFILE_AV1_HIGH) },
1395 { PROFILE("professional", AV_PROFILE_AV1_PROFESSIONAL) },
1396 #undef PROFILE
1397
1398 { "tier", "Set tier (seq_tier)",
1399 OFFSET(common.opts.tier), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS, .unit = "tier" },
1400 { "main", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, FLAGS, .unit = "tier" },
1401 { "high", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, FLAGS, .unit = "tier" },
1402
1403 { "level", "Set level (level_idc)",
1404 OFFSET(common.opts.level), AV_OPT_TYPE_INT,
1405 { .i64 = AV_LEVEL_UNKNOWN }, AV_LEVEL_UNKNOWN, 0xff, FLAGS, .unit = "level" },
1406
1407 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1408 { .i64 = value }, 0, 0, FLAGS, .unit = "level"
1409 { LEVEL("20", 0) },
1410 { LEVEL("21", 1) },
1411 { LEVEL("22", 2) },
1412 { LEVEL("23", 3) },
1413 { LEVEL("30", 4) },
1414 { LEVEL("31", 5) },
1415 { LEVEL("32", 6) },
1416 { LEVEL("33", 7) },
1417 { LEVEL("40", 8) },
1418 { LEVEL("41", 9) },
1419 { LEVEL("42", 10) },
1420 { LEVEL("43", 11) },
1421 { LEVEL("50", 12) },
1422 { LEVEL("51", 13) },
1423 { LEVEL("52", 14) },
1424 { LEVEL("53", 15) },
1425 { LEVEL("60", 16) },
1426 { LEVEL("61", 17) },
1427 { LEVEL("62", 18) },
1428 { LEVEL("63", 19) },
1429 { LEVEL("70", 20) },
1430 { LEVEL("71", 21) },
1431 { LEVEL("72", 22) },
1432 { LEVEL("73", 23) },
1433 #undef LEVEL
1434
1435 { "units", "Set units to include", OFFSET(unit_elems), AV_OPT_TYPE_FLAGS, { .i64 = UNIT_MASTERING_DISPLAY | UNIT_CONTENT_LIGHT_LEVEL }, 0, INT_MAX, FLAGS, "units" },
1436 { "hdr", "Include HDR metadata for mastering display colour volume and content light level information", 0, AV_OPT_TYPE_CONST, { .i64 = UNIT_MASTERING_DISPLAY | UNIT_CONTENT_LIGHT_LEVEL }, INT_MIN, INT_MAX, FLAGS, "units" },
1437
1438 { NULL },
1439 };
1440
1441 static const FFCodecDefault vulkan_encode_av1_defaults[] = {
1442 { "b", "0" },
1443 { "bf", "2" },
1444 { "g", "300" },
1445 { "qmin", "1" },
1446 { "qmax", "255" },
1447 { "refs", "0" },
1448 { NULL },
1449 };
1450
1451 static const AVClass vulkan_encode_av1_class = {
1452 .class_name = "av1_vulkan",
1453 .item_name = av_default_item_name,
1454 .option = vulkan_encode_av1_options,
1455 .version = LIBAVUTIL_VERSION_INT,
1456 };
1457
1458 const FFCodec ff_av1_vulkan_encoder = {
1459 .p.name = "av1_vulkan",
1460 CODEC_LONG_NAME("AV1 (Vulkan)"),
1461 .p.type = AVMEDIA_TYPE_VIDEO,
1462 .p.id = AV_CODEC_ID_AV1,
1463 .priv_data_size = sizeof(VulkanEncodeAV1Context),
1464 .init = &vulkan_encode_av1_init,
1465 FF_CODEC_RECEIVE_PACKET_CB(&ff_vulkan_encode_receive_packet),
1466 .close = &vulkan_encode_av1_close,
1467 .p.priv_class = &vulkan_encode_av1_class,
1468 .p.capabilities = AV_CODEC_CAP_DELAY |
1469 AV_CODEC_CAP_HARDWARE |
1470 AV_CODEC_CAP_DR1 |
1471 AV_CODEC_CAP_ENCODER_FLUSH |
1472 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1473 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1474 .defaults = vulkan_encode_av1_defaults,
1475 CODEC_PIXFMTS(AV_PIX_FMT_VULKAN),
1476 .hw_configs = ff_vulkan_encode_hw_configs,
1477 .p.wrapper_name = "vulkan",
1478 };
1479