FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/vaapi_encode_h265.c
Date: 2022-07-04 00:18:54
Exec Total Coverage
Lines: 0 718 0.0%
Branches: 0 313 0.0%
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 <string.h>
20
21 #include <va/va.h>
22 #include <va/va_enc_hevc.h>
23
24 #include "libavutil/avassert.h"
25 #include "libavutil/common.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/mastering_display_metadata.h"
29
30 #include "avcodec.h"
31 #include "cbs.h"
32 #include "cbs_h265.h"
33 #include "codec_internal.h"
34 #include "h265_profile_level.h"
35 #include "hevc.h"
36 #include "hevc_sei.h"
37 #include "put_bits.h"
38 #include "vaapi_encode.h"
39
40 enum {
41 SEI_MASTERING_DISPLAY = 0x08,
42 SEI_CONTENT_LIGHT_LEVEL = 0x10,
43 };
44
45 typedef struct VAAPIEncodeH265Picture {
46 int pic_order_cnt;
47
48 int64_t last_idr_frame;
49
50 int slice_nal_unit;
51 int slice_type;
52 int pic_type;
53 } VAAPIEncodeH265Picture;
54
55 typedef struct VAAPIEncodeH265Context {
56 VAAPIEncodeContext common;
57
58 // Encoder features.
59 uint32_t va_features;
60 // Block size info.
61 uint32_t va_bs;
62 uint32_t ctu_size;
63 uint32_t min_cb_size;
64
65 // User options.
66 int qp;
67 int aud;
68 int profile;
69 int tier;
70 int level;
71 int sei;
72
73 // Derived settings.
74 int fixed_qp_idr;
75 int fixed_qp_p;
76 int fixed_qp_b;
77
78 // Writer structures.
79 H265RawAUD raw_aud;
80 H265RawVPS raw_vps;
81 H265RawSPS raw_sps;
82 H265RawPPS raw_pps;
83 H265RawSlice raw_slice;
84
85 SEIRawMasteringDisplayColourVolume sei_mastering_display;
86 SEIRawContentLightLevelInfo sei_content_light_level;
87
88 CodedBitstreamContext *cbc;
89 CodedBitstreamFragment current_access_unit;
90 int aud_needed;
91 int sei_needed;
92 } VAAPIEncodeH265Context;
93
94
95 ✗ static int vaapi_encode_h265_write_access_unit(AVCodecContext *avctx,
96 char *data, size_t *data_len,
97 CodedBitstreamFragment *au)
98 {
99 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
100 int err;
101
102 ✗ err = ff_cbs_write_fragment_data(priv->cbc, au);
103 ✗ if (err < 0) {
104 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to write packed header.\n");
105 ✗ return err;
106 }
107
108 ✗ if (*data_len < 8 * au->data_size - au->data_bit_padding) {
109 ✗ av_log(avctx, AV_LOG_ERROR, "Access unit too large: "
110 "%zu < %zu.\n", *data_len,
111 ✗ 8 * au->data_size - au->data_bit_padding);
112 ✗ return AVERROR(ENOSPC);
113 }
114
115 ✗ memcpy(data, au->data, au->data_size);
116 ✗ *data_len = 8 * au->data_size - au->data_bit_padding;
117
118 ✗ return 0;
119 }
120
121 ✗ static int vaapi_encode_h265_add_nal(AVCodecContext *avctx,
122 CodedBitstreamFragment *au,
123 void *nal_unit)
124 {
125 ✗ H265RawNALUnitHeader *header = nal_unit;
126 int err;
127
128 ✗ err = ff_cbs_insert_unit_content(au, -1,
129 ✗ header->nal_unit_type, nal_unit, NULL);
130 ✗ if (err < 0) {
131 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to add NAL unit: "
132 ✗ "type = %d.\n", header->nal_unit_type);
133 ✗ return err;
134 }
135
136 ✗ return 0;
137 }
138
139 ✗ static int vaapi_encode_h265_write_sequence_header(AVCodecContext *avctx,
140 char *data, size_t *data_len)
141 {
142 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
143 ✗ CodedBitstreamFragment *au = &priv->current_access_unit;
144 int err;
145
146 ✗ if (priv->aud_needed) {
147 ✗ err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
148 ✗ if (err < 0)
149 ✗ goto fail;
150 ✗ priv->aud_needed = 0;
151 }
152
153 ✗ err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_vps);
154 ✗ if (err < 0)
155 ✗ goto fail;
156
157 ✗ err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_sps);
158 ✗ if (err < 0)
159 ✗ goto fail;
160
161 ✗ err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_pps);
162 ✗ if (err < 0)
163 ✗ goto fail;
164
165 ✗ err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
166 ✗ fail:
167 ✗ ff_cbs_fragment_reset(au);
168 ✗ return err;
169 }
170
171 ✗ static int vaapi_encode_h265_write_slice_header(AVCodecContext *avctx,
172 VAAPIEncodePicture *pic,
173 VAAPIEncodeSlice *slice,
174 char *data, size_t *data_len)
175 {
176 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
177 ✗ CodedBitstreamFragment *au = &priv->current_access_unit;
178 int err;
179
180 ✗ if (priv->aud_needed) {
181 ✗ err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_aud);
182 ✗ if (err < 0)
183 ✗ goto fail;
184 ✗ priv->aud_needed = 0;
185 }
186
187 ✗ err = vaapi_encode_h265_add_nal(avctx, au, &priv->raw_slice);
188 ✗ if (err < 0)
189 ✗ goto fail;
190
191 ✗ err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
192 ✗ fail:
193 ✗ ff_cbs_fragment_reset(au);
194 ✗ return err;
195 }
196
197 ✗ static int vaapi_encode_h265_write_extra_header(AVCodecContext *avctx,
198 VAAPIEncodePicture *pic,
199 int index, int *type,
200 char *data, size_t *data_len)
201 {
202 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
203 ✗ CodedBitstreamFragment *au = &priv->current_access_unit;
204 int err;
205
206 ✗ if (priv->sei_needed) {
207 ✗ if (priv->aud_needed) {
208 ✗ err = vaapi_encode_h265_add_nal(avctx, au, &priv->aud);
209 ✗ if (err < 0)
210 ✗ goto fail;
211 ✗ priv->aud_needed = 0;
212 }
213
214 ✗ if (priv->sei_needed & SEI_MASTERING_DISPLAY) {
215 ✗ err = ff_cbs_sei_add_message(priv->cbc, au, 1,
216 SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME,
217 ✗ &priv->sei_mastering_display, NULL);
218 ✗ if (err < 0)
219 ✗ goto fail;
220 }
221
222 ✗ if (priv->sei_needed & SEI_CONTENT_LIGHT_LEVEL) {
223 ✗ err = ff_cbs_sei_add_message(priv->cbc, au, 1,
224 SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO,
225 ✗ &priv->sei_content_light_level, NULL);
226 ✗ if (err < 0)
227 ✗ goto fail;
228 }
229
230 ✗ priv->sei_needed = 0;
231
232 ✗ err = vaapi_encode_h265_write_access_unit(avctx, data, data_len, au);
233 ✗ if (err < 0)
234 ✗ goto fail;
235
236 ✗ ff_cbs_fragment_reset(au);
237
238 ✗ *type = VAEncPackedHeaderRawData;
239 ✗ return 0;
240 } else {
241 ✗ return AVERROR_EOF;
242 }
243
244 ✗ fail:
245 ✗ ff_cbs_fragment_reset(au);
246 ✗ return err;
247 }
248
249 ✗ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
250 {
251 ✗ VAAPIEncodeContext *ctx = avctx->priv_data;
252 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
253 ✗ H265RawVPS *vps = &priv->raw_vps;
254 ✗ H265RawSPS *sps = &priv->raw_sps;
255 ✗ H265RawPPS *pps = &priv->raw_pps;
256 ✗ H265RawProfileTierLevel *ptl = &vps->profile_tier_level;
257 ✗ H265RawVUI *vui = &sps->vui;
258 ✗ VAEncSequenceParameterBufferHEVC *vseq = ctx->codec_sequence_params;
259 ✗ VAEncPictureParameterBufferHEVC *vpic = ctx->codec_picture_params;
260 const AVPixFmtDescriptor *desc;
261 int chroma_format, bit_depth;
262 int i;
263
264 ✗ memset(vps, 0, sizeof(*vps));
265 ✗ memset(sps, 0, sizeof(*sps));
266 ✗ memset(pps, 0, sizeof(*pps));
267
268
269 ✗ desc = av_pix_fmt_desc_get(priv->common.input_frames->sw_format);
270 ✗ av_assert0(desc);
271 ✗ if (desc->nb_components == 1) {
272 ✗ chroma_format = 0;
273 } else {
274 ✗ if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 1) {
275 ✗ chroma_format = 1;
276 ✗ } else if (desc->log2_chroma_w == 1 && desc->log2_chroma_h == 0) {
277 ✗ chroma_format = 2;
278 ✗ } else if (desc->log2_chroma_w == 0 && desc->log2_chroma_h == 0) {
279 ✗ chroma_format = 3;
280 } else {
281 ✗ av_log(avctx, AV_LOG_ERROR, "Chroma format of input pixel format "
282 ✗ "%s is not supported.\n", desc->name);
283 ✗ return AVERROR(EINVAL);
284 }
285 }
286 ✗ bit_depth = desc->comp[0].depth;
287
288
289 // VPS
290
291 ✗ vps->nal_unit_header = (H265RawNALUnitHeader) {
292 .nal_unit_type = HEVC_NAL_VPS,
293 .nuh_layer_id = 0,
294 .nuh_temporal_id_plus1 = 1,
295 };
296
297 ✗ vps->vps_video_parameter_set_id = 0;
298
299 ✗ vps->vps_base_layer_internal_flag = 1;
300 ✗ vps->vps_base_layer_available_flag = 1;
301 ✗ vps->vps_max_layers_minus1 = 0;
302 ✗ vps->vps_max_sub_layers_minus1 = 0;
303 ✗ vps->vps_temporal_id_nesting_flag = 1;
304
305 ✗ ptl->general_profile_space = 0;
306 ✗ ptl->general_profile_idc = avctx->profile;
307 ✗ ptl->general_tier_flag = priv->tier;
308
309 ✗ ptl->general_profile_compatibility_flag[ptl->general_profile_idc] = 1;
310
311 ✗ if (ptl->general_profile_compatibility_flag[1])
312 ✗ ptl->general_profile_compatibility_flag[2] = 1;
313 ✗ if (ptl->general_profile_compatibility_flag[3]) {
314 ✗ ptl->general_profile_compatibility_flag[1] = 1;
315 ✗ ptl->general_profile_compatibility_flag[2] = 1;
316 }
317
318 ✗ ptl->general_progressive_source_flag = 1;
319 ✗ ptl->general_interlaced_source_flag = 0;
320 ✗ ptl->general_non_packed_constraint_flag = 1;
321 ✗ ptl->general_frame_only_constraint_flag = 1;
322
323 ✗ ptl->general_max_14bit_constraint_flag = bit_depth <= 14;
324 ✗ ptl->general_max_12bit_constraint_flag = bit_depth <= 12;
325 ✗ ptl->general_max_10bit_constraint_flag = bit_depth <= 10;
326 ✗ ptl->general_max_8bit_constraint_flag = bit_depth == 8;
327
328 ✗ ptl->general_max_422chroma_constraint_flag = chroma_format <= 2;
329 ✗ ptl->general_max_420chroma_constraint_flag = chroma_format <= 1;
330 ✗ ptl->general_max_monochrome_constraint_flag = chroma_format == 0;
331
332 ✗ ptl->general_intra_constraint_flag = ctx->gop_size == 1;
333 ✗ ptl->general_one_picture_only_constraint_flag = 0;
334
335 ✗ ptl->general_lower_bit_rate_constraint_flag = 1;
336
337 ✗ if (avctx->level != FF_LEVEL_UNKNOWN) {
338 ✗ ptl->general_level_idc = avctx->level;
339 } else {
340 const H265LevelDescriptor *level;
341
342 ✗ level = ff_h265_guess_level(ptl, avctx->bit_rate,
343 ctx->surface_width, ctx->surface_height,
344 ctx->nb_slices, ctx->tile_rows, ctx->tile_cols,
345 ✗ (ctx->b_per_p > 0) + 1);
346 ✗ if (level) {
347 ✗ av_log(avctx, AV_LOG_VERBOSE, "Using level %s.\n", level->name);
348 ✗ ptl->general_level_idc = level->level_idc;
349 } else {
350 ✗ av_log(avctx, AV_LOG_VERBOSE, "Stream will not conform to "
351 "any normal level; using level 8.5.\n");
352 ✗ ptl->general_level_idc = 255;
353 // The tier flag must be set in level 8.5.
354 ✗ ptl->general_tier_flag = 1;
355 }
356 }
357
358 ✗ vps->vps_sub_layer_ordering_info_present_flag = 0;
359 ✗ vps->vps_max_dec_pic_buffering_minus1[0] = ctx->max_b_depth + 1;
360 ✗ vps->vps_max_num_reorder_pics[0] = ctx->max_b_depth;
361 ✗ vps->vps_max_latency_increase_plus1[0] = 0;
362
363 ✗ vps->vps_max_layer_id = 0;
364 ✗ vps->vps_num_layer_sets_minus1 = 0;
365 ✗ vps->layer_id_included_flag[0][0] = 1;
366
367 ✗ vps->vps_timing_info_present_flag = 1;
368 ✗ if (avctx->framerate.num > 0 && avctx->framerate.den > 0) {
369 ✗ vps->vps_num_units_in_tick = avctx->framerate.den;
370 ✗ vps->vps_time_scale = avctx->framerate.num;
371 ✗ vps->vps_poc_proportional_to_timing_flag = 1;
372 ✗ vps->vps_num_ticks_poc_diff_one_minus1 = 0;
373 } else {
374 ✗ vps->vps_num_units_in_tick = avctx->time_base.num;
375 ✗ vps->vps_time_scale = avctx->time_base.den;
376 ✗ vps->vps_poc_proportional_to_timing_flag = 0;
377 }
378 ✗ vps->vps_num_hrd_parameters = 0;
379
380
381 // SPS
382
383 ✗ sps->nal_unit_header = (H265RawNALUnitHeader) {
384 .nal_unit_type = HEVC_NAL_SPS,
385 .nuh_layer_id = 0,
386 .nuh_temporal_id_plus1 = 1,
387 };
388
389 ✗ sps->sps_video_parameter_set_id = vps->vps_video_parameter_set_id;
390
391 ✗ sps->sps_max_sub_layers_minus1 = vps->vps_max_sub_layers_minus1;
392 ✗ sps->sps_temporal_id_nesting_flag = vps->vps_temporal_id_nesting_flag;
393
394 ✗ sps->profile_tier_level = vps->profile_tier_level;
395
396 ✗ sps->sps_seq_parameter_set_id = 0;
397
398 ✗ sps->chroma_format_idc = chroma_format;
399 ✗ sps->separate_colour_plane_flag = 0;
400
401 ✗ sps->pic_width_in_luma_samples = ctx->surface_width;
402 ✗ sps->pic_height_in_luma_samples = ctx->surface_height;
403
404 ✗ if (avctx->width != ctx->surface_width ||
405 ✗ avctx->height != ctx->surface_height) {
406 ✗ sps->conformance_window_flag = 1;
407 ✗ sps->conf_win_left_offset = 0;
408 ✗ sps->conf_win_right_offset =
409 ✗ (ctx->surface_width - avctx->width) >> desc->log2_chroma_w;
410 ✗ sps->conf_win_top_offset = 0;
411 ✗ sps->conf_win_bottom_offset =
412 ✗ (ctx->surface_height - avctx->height) >> desc->log2_chroma_h;
413 } else {
414 ✗ sps->conformance_window_flag = 0;
415 }
416
417 ✗ sps->bit_depth_luma_minus8 = bit_depth - 8;
418 ✗ sps->bit_depth_chroma_minus8 = bit_depth - 8;
419
420 ✗ sps->log2_max_pic_order_cnt_lsb_minus4 = 8;
421
422 ✗ sps->sps_sub_layer_ordering_info_present_flag =
423 ✗ vps->vps_sub_layer_ordering_info_present_flag;
424 ✗ for (i = 0; i <= sps->sps_max_sub_layers_minus1; i++) {
425 ✗ sps->sps_max_dec_pic_buffering_minus1[i] =
426 ✗ vps->vps_max_dec_pic_buffering_minus1[i];
427 ✗ sps->sps_max_num_reorder_pics[i] =
428 ✗ vps->vps_max_num_reorder_pics[i];
429 ✗ sps->sps_max_latency_increase_plus1[i] =
430 ✗ vps->vps_max_latency_increase_plus1[i];
431 }
432
433 // These values come from the capabilities of the first encoder
434 // implementation in the i965 driver on Intel Skylake. They may
435 // fail badly with other platforms or drivers.
436 // CTB size from 8x8 to 32x32.
437 ✗ sps->log2_min_luma_coding_block_size_minus3 = 0;
438 ✗ sps->log2_diff_max_min_luma_coding_block_size = 2;
439 // Transform size from 4x4 to 32x32.
440 ✗ sps->log2_min_luma_transform_block_size_minus2 = 0;
441 ✗ sps->log2_diff_max_min_luma_transform_block_size = 3;
442 // Full transform hierarchy allowed (2-5).
443 ✗ sps->max_transform_hierarchy_depth_inter = 3;
444 ✗ sps->max_transform_hierarchy_depth_intra = 3;
445 // AMP works.
446 ✗ sps->amp_enabled_flag = 1;
447 // SAO and temporal MVP do not work.
448 ✗ sps->sample_adaptive_offset_enabled_flag = 0;
449 ✗ sps->sps_temporal_mvp_enabled_flag = 0;
450
451 ✗ sps->pcm_enabled_flag = 0;
452
453 // update sps setting according to queried result
454 #if VA_CHECK_VERSION(1, 13, 0)
455 ✗ if (priv->va_features) {
456 ✗ VAConfigAttribValEncHEVCFeatures features = { .value = priv->va_features };
457
458 // Enable feature if get queried result is VA_FEATURE_SUPPORTED | VA_FEATURE_REQUIRED
459 ✗ sps->amp_enabled_flag =
460 ✗ !!features.bits.amp;
461 ✗ sps->sample_adaptive_offset_enabled_flag =
462 ✗ !!features.bits.sao;
463 ✗ sps->sps_temporal_mvp_enabled_flag =
464 ✗ !!features.bits.temporal_mvp;
465 ✗ sps->pcm_enabled_flag =
466 ✗ !!features.bits.pcm;
467 }
468
469 ✗ if (priv->va_bs) {
470 ✗ VAConfigAttribValEncHEVCBlockSizes bs = { .value = priv->va_bs };
471 ✗ sps->log2_min_luma_coding_block_size_minus3 =
472 ✗ ff_ctz(priv->min_cb_size) - 3;
473 ✗ sps->log2_diff_max_min_luma_coding_block_size =
474 ✗ ff_ctz(priv->ctu_size) - ff_ctz(priv->min_cb_size);
475
476 ✗ sps->log2_min_luma_transform_block_size_minus2 =
477 ✗ bs.bits.log2_min_luma_transform_block_size_minus2;
478 ✗ sps->log2_diff_max_min_luma_transform_block_size =
479 ✗ bs.bits.log2_max_luma_transform_block_size_minus2 -
480 ✗ bs.bits.log2_min_luma_transform_block_size_minus2;
481
482 ✗ sps->max_transform_hierarchy_depth_inter =
483 ✗ bs.bits.max_max_transform_hierarchy_depth_inter;
484 ✗ sps->max_transform_hierarchy_depth_intra =
485 ✗ bs.bits.max_max_transform_hierarchy_depth_intra;
486 }
487 #endif
488
489 // STRPSs should ideally be here rather than defined individually in
490 // each slice, but the structure isn't completely fixed so for now
491 // don't bother.
492 ✗ sps->num_short_term_ref_pic_sets = 0;
493 ✗ sps->long_term_ref_pics_present_flag = 0;
494
495 ✗ sps->vui_parameters_present_flag = 1;
496
497 ✗ if (avctx->sample_aspect_ratio.num != 0 &&
498 ✗ avctx->sample_aspect_ratio.den != 0) {
499 static const AVRational sar_idc[] = {
500 { 0, 0 },
501 { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
502 { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
503 { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
504 { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
505 };
506 int num, den, i;
507 ✗ av_reduce(&num, &den, avctx->sample_aspect_ratio.num,
508 ✗ avctx->sample_aspect_ratio.den, 65535);
509 ✗ for (i = 0; i < FF_ARRAY_ELEMS(sar_idc); i++) {
510 ✗ if (num == sar_idc[i].num &&
511 ✗ den == sar_idc[i].den) {
512 ✗ vui->aspect_ratio_idc = i;
513 ✗ break;
514 }
515 }
516 ✗ if (i >= FF_ARRAY_ELEMS(sar_idc)) {
517 ✗ vui->aspect_ratio_idc = 255;
518 ✗ vui->sar_width = num;
519 ✗ vui->sar_height = den;
520 }
521 ✗ vui->aspect_ratio_info_present_flag = 1;
522 }
523
524 // Unspecified video format, from table E-2.
525 ✗ vui->video_format = 5;
526 ✗ vui->video_full_range_flag =
527 ✗ avctx->color_range == AVCOL_RANGE_JPEG;
528 ✗ vui->colour_primaries = avctx->color_primaries;
529 ✗ vui->transfer_characteristics = avctx->color_trc;
530 ✗ vui->matrix_coefficients = avctx->colorspace;
531 ✗ if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED ||
532 ✗ avctx->color_trc != AVCOL_TRC_UNSPECIFIED ||
533 ✗ avctx->colorspace != AVCOL_SPC_UNSPECIFIED)
534 ✗ vui->colour_description_present_flag = 1;
535 ✗ if (avctx->color_range != AVCOL_RANGE_UNSPECIFIED ||
536 ✗ vui->colour_description_present_flag)
537 ✗ vui->video_signal_type_present_flag = 1;
538
539 ✗ if (avctx->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED) {
540 ✗ vui->chroma_loc_info_present_flag = 1;
541 ✗ vui->chroma_sample_loc_type_top_field =
542 ✗ vui->chroma_sample_loc_type_bottom_field =
543 ✗ avctx->chroma_sample_location - 1;
544 }
545
546 ✗ vui->vui_timing_info_present_flag = 1;
547 ✗ vui->vui_num_units_in_tick = vps->vps_num_units_in_tick;
548 ✗ vui->vui_time_scale = vps->vps_time_scale;
549 ✗ vui->vui_poc_proportional_to_timing_flag = vps->vps_poc_proportional_to_timing_flag;
550 ✗ vui->vui_num_ticks_poc_diff_one_minus1 = vps->vps_num_ticks_poc_diff_one_minus1;
551 ✗ vui->vui_hrd_parameters_present_flag = 0;
552
553 ✗ vui->bitstream_restriction_flag = 1;
554 ✗ vui->motion_vectors_over_pic_boundaries_flag = 1;
555 ✗ vui->restricted_ref_pic_lists_flag = 1;
556 ✗ vui->max_bytes_per_pic_denom = 0;
557 ✗ vui->max_bits_per_min_cu_denom = 0;
558 ✗ vui->log2_max_mv_length_horizontal = 15;
559 ✗ vui->log2_max_mv_length_vertical = 15;
560
561
562 // PPS
563
564 ✗ pps->nal_unit_header = (H265RawNALUnitHeader) {
565 .nal_unit_type = HEVC_NAL_PPS,
566 .nuh_layer_id = 0,
567 .nuh_temporal_id_plus1 = 1,
568 };
569
570 ✗ pps->pps_pic_parameter_set_id = 0;
571 ✗ pps->pps_seq_parameter_set_id = sps->sps_seq_parameter_set_id;
572
573 ✗ pps->num_ref_idx_l0_default_active_minus1 = 0;
574 ✗ pps->num_ref_idx_l1_default_active_minus1 = 0;
575
576 ✗ pps->init_qp_minus26 = priv->fixed_qp_idr - 26;
577
578 ✗ pps->cu_qp_delta_enabled_flag = (ctx->va_rc_mode != VA_RC_CQP);
579 ✗ pps->diff_cu_qp_delta_depth = 0;
580
581 // update pps setting according to queried result
582 #if VA_CHECK_VERSION(1, 13, 0)
583 ✗ if (priv->va_features) {
584 ✗ VAConfigAttribValEncHEVCFeatures features = { .value = priv->va_features };
585 ✗ if (ctx->va_rc_mode != VA_RC_CQP)
586 ✗ pps->cu_qp_delta_enabled_flag =
587 ✗ !!features.bits.cu_qp_delta;
588
589 ✗ pps->transform_skip_enabled_flag =
590 ✗ !!features.bits.transform_skip;
591 // set diff_cu_qp_delta_depth as its max value if cu_qp_delta enabled. Otherwise
592 // 0 will make cu_qp_delta invalid.
593 ✗ if (pps->cu_qp_delta_enabled_flag)
594 ✗ pps->diff_cu_qp_delta_depth = sps->log2_diff_max_min_luma_coding_block_size;
595 }
596 #endif
597
598 ✗ if (ctx->tile_rows && ctx->tile_cols) {
599 int uniform_spacing;
600
601 ✗ pps->tiles_enabled_flag = 1;
602 ✗ pps->num_tile_columns_minus1 = ctx->tile_cols - 1;
603 ✗ pps->num_tile_rows_minus1 = ctx->tile_rows - 1;
604
605 // Test whether the spacing provided matches the H.265 uniform
606 // spacing, and set the flag if it does.
607 ✗ uniform_spacing = 1;
608 ✗ for (i = 0; i <= pps->num_tile_columns_minus1 &&
609 ✗ uniform_spacing; i++) {
610 ✗ if (ctx->col_width[i] !=
611 ✗ (i + 1) * ctx->slice_block_cols / ctx->tile_cols -
612 ✗ i * ctx->slice_block_cols / ctx->tile_cols)
613 ✗ uniform_spacing = 0;
614 }
615 ✗ for (i = 0; i <= pps->num_tile_rows_minus1 &&
616 ✗ uniform_spacing; i++) {
617 ✗ if (ctx->row_height[i] !=
618 ✗ (i + 1) * ctx->slice_block_rows / ctx->tile_rows -
619 ✗ i * ctx->slice_block_rows / ctx->tile_rows)
620 ✗ uniform_spacing = 0;
621 }
622 ✗ pps->uniform_spacing_flag = uniform_spacing;
623
624 ✗ for (i = 0; i <= pps->num_tile_columns_minus1; i++)
625 ✗ pps->column_width_minus1[i] = ctx->col_width[i] - 1;
626 ✗ for (i = 0; i <= pps->num_tile_rows_minus1; i++)
627 ✗ pps->row_height_minus1[i] = ctx->row_height[i] - 1;
628
629 ✗ pps->loop_filter_across_tiles_enabled_flag = 1;
630 }
631
632 ✗ pps->pps_loop_filter_across_slices_enabled_flag = 1;
633
634 // Fill VAAPI parameter buffers.
635
636 ✗ *vseq = (VAEncSequenceParameterBufferHEVC) {
637 ✗ .general_profile_idc = vps->profile_tier_level.general_profile_idc,
638 ✗ .general_level_idc = vps->profile_tier_level.general_level_idc,
639 ✗ .general_tier_flag = vps->profile_tier_level.general_tier_flag,
640
641 ✗ .intra_period = ctx->gop_size,
642 ✗ .intra_idr_period = ctx->gop_size,
643 ✗ .ip_period = ctx->b_per_p + 1,
644 ✗ .bits_per_second = ctx->va_bit_rate,
645
646 ✗ .pic_width_in_luma_samples = sps->pic_width_in_luma_samples,
647 ✗ .pic_height_in_luma_samples = sps->pic_height_in_luma_samples,
648
649 .seq_fields.bits = {
650 ✗ .chroma_format_idc = sps->chroma_format_idc,
651 ✗ .separate_colour_plane_flag = sps->separate_colour_plane_flag,
652 ✗ .bit_depth_luma_minus8 = sps->bit_depth_luma_minus8,
653 ✗ .bit_depth_chroma_minus8 = sps->bit_depth_chroma_minus8,
654 ✗ .scaling_list_enabled_flag = sps->scaling_list_enabled_flag,
655 .strong_intra_smoothing_enabled_flag =
656 ✗ sps->strong_intra_smoothing_enabled_flag,
657 ✗ .amp_enabled_flag = sps->amp_enabled_flag,
658 .sample_adaptive_offset_enabled_flag =
659 ✗ sps->sample_adaptive_offset_enabled_flag,
660 ✗ .pcm_enabled_flag = sps->pcm_enabled_flag,
661 ✗ .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled_flag,
662 ✗ .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
663 },
664
665 .log2_min_luma_coding_block_size_minus3 =
666 ✗ sps->log2_min_luma_coding_block_size_minus3,
667 .log2_diff_max_min_luma_coding_block_size =
668 ✗ sps->log2_diff_max_min_luma_coding_block_size,
669 .log2_min_transform_block_size_minus2 =
670 ✗ sps->log2_min_luma_transform_block_size_minus2,
671 .log2_diff_max_min_transform_block_size =
672 ✗ sps->log2_diff_max_min_luma_transform_block_size,
673 .max_transform_hierarchy_depth_inter =
674 ✗ sps->max_transform_hierarchy_depth_inter,
675 .max_transform_hierarchy_depth_intra =
676 ✗ sps->max_transform_hierarchy_depth_intra,
677
678 .pcm_sample_bit_depth_luma_minus1 =
679 ✗ sps->pcm_sample_bit_depth_luma_minus1,
680 .pcm_sample_bit_depth_chroma_minus1 =
681 ✗ sps->pcm_sample_bit_depth_chroma_minus1,
682 .log2_min_pcm_luma_coding_block_size_minus3 =
683 ✗ sps->log2_min_pcm_luma_coding_block_size_minus3,
684 .log2_max_pcm_luma_coding_block_size_minus3 =
685 ✗ sps->log2_min_pcm_luma_coding_block_size_minus3 +
686 ✗ sps->log2_diff_max_min_pcm_luma_coding_block_size,
687
688 .vui_parameters_present_flag = 0,
689 };
690
691 ✗ *vpic = (VAEncPictureParameterBufferHEVC) {
692 .decoded_curr_pic = {
693 .picture_id = VA_INVALID_ID,
694 .flags = VA_PICTURE_HEVC_INVALID,
695 },
696
697 .coded_buf = VA_INVALID_ID,
698
699 ✗ .collocated_ref_pic_index = sps->sps_temporal_mvp_enabled_flag ?
700 0 : 0xff,
701 .last_picture = 0,
702
703 ✗ .pic_init_qp = pps->init_qp_minus26 + 26,
704 ✗ .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
705 ✗ .pps_cb_qp_offset = pps->pps_cb_qp_offset,
706 ✗ .pps_cr_qp_offset = pps->pps_cr_qp_offset,
707
708 ✗ .num_tile_columns_minus1 = pps->num_tile_columns_minus1,
709 ✗ .num_tile_rows_minus1 = pps->num_tile_rows_minus1,
710
711 ✗ .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level_minus2,
712 .ctu_max_bitsize_allowed = 0,
713
714 .num_ref_idx_l0_default_active_minus1 =
715 ✗ pps->num_ref_idx_l0_default_active_minus1,
716 .num_ref_idx_l1_default_active_minus1 =
717 ✗ pps->num_ref_idx_l1_default_active_minus1,
718
719 ✗ .slice_pic_parameter_set_id = pps->pps_pic_parameter_set_id,
720
721 .pic_fields.bits = {
722 ✗ .sign_data_hiding_enabled_flag = pps->sign_data_hiding_enabled_flag,
723 ✗ .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
724 ✗ .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
725 ✗ .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
726 ✗ .weighted_pred_flag = pps->weighted_pred_flag,
727 ✗ .weighted_bipred_flag = pps->weighted_bipred_flag,
728 ✗ .transquant_bypass_enabled_flag = pps->transquant_bypass_enabled_flag,
729 ✗ .tiles_enabled_flag = pps->tiles_enabled_flag,
730 ✗ .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
731 .loop_filter_across_tiles_enabled_flag =
732 ✗ pps->loop_filter_across_tiles_enabled_flag,
733 .pps_loop_filter_across_slices_enabled_flag =
734 ✗ pps->pps_loop_filter_across_slices_enabled_flag,
735 ✗ .scaling_list_data_present_flag = (sps->sps_scaling_list_data_present_flag |
736 ✗ pps->pps_scaling_list_data_present_flag),
737 .screen_content_flag = 0,
738 .enable_gpu_weighted_prediction = 0,
739 .no_output_of_prior_pics_flag = 0,
740 },
741 };
742
743 ✗ if (pps->tiles_enabled_flag) {
744 ✗ for (i = 0; i <= vpic->num_tile_rows_minus1; i++)
745 ✗ vpic->row_height_minus1[i] = pps->row_height_minus1[i];
746 ✗ for (i = 0; i <= vpic->num_tile_columns_minus1; i++)
747 ✗ vpic->column_width_minus1[i] = pps->column_width_minus1[i];
748 }
749
750 ✗ return 0;
751 }
752
753 ✗ static int vaapi_encode_h265_init_picture_params(AVCodecContext *avctx,
754 VAAPIEncodePicture *pic)
755 {
756 ✗ VAAPIEncodeContext *ctx = avctx->priv_data;
757 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
758 ✗ VAAPIEncodeH265Picture *hpic = pic->priv_data;
759 ✗ VAAPIEncodePicture *prev = pic->prev;
760 ✗ VAAPIEncodeH265Picture *hprev = prev ? prev->priv_data : NULL;
761 ✗ VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
762 int i;
763
764 ✗ if (pic->type == PICTURE_TYPE_IDR) {
765 ✗ av_assert0(pic->display_order == pic->encode_order);
766
767 ✗ hpic->last_idr_frame = pic->display_order;
768
769 ✗ hpic->slice_nal_unit = HEVC_NAL_IDR_W_RADL;
770 ✗ hpic->slice_type = HEVC_SLICE_I;
771 ✗ hpic->pic_type = 0;
772 } else {
773 ✗ av_assert0(prev);
774 ✗ hpic->last_idr_frame = hprev->last_idr_frame;
775
776 ✗ if (pic->type == PICTURE_TYPE_I) {
777 ✗ hpic->slice_nal_unit = HEVC_NAL_CRA_NUT;
778 ✗ hpic->slice_type = HEVC_SLICE_I;
779 ✗ hpic->pic_type = 0;
780 ✗ } else if (pic->type == PICTURE_TYPE_P) {
781 ✗ av_assert0(pic->refs[0]);
782 ✗ hpic->slice_nal_unit = HEVC_NAL_TRAIL_R;
783 ✗ hpic->slice_type = HEVC_SLICE_P;
784 ✗ hpic->pic_type = 1;
785 } else {
786 VAAPIEncodePicture *irap_ref;
787 ✗ av_assert0(pic->refs[0] && pic->refs[1]);
788 ✗ for (irap_ref = pic; irap_ref; irap_ref = irap_ref->refs[1]) {
789 ✗ if (irap_ref->type == PICTURE_TYPE_I)
790 ✗ break;
791 }
792 ✗ if (pic->b_depth == ctx->max_b_depth) {
793 ✗ hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_N
794 ✗ : HEVC_NAL_TRAIL_N;
795 } else {
796 ✗ hpic->slice_nal_unit = irap_ref ? HEVC_NAL_RASL_R
797 ✗ : HEVC_NAL_TRAIL_R;
798 }
799 ✗ hpic->slice_type = HEVC_SLICE_B;
800 ✗ hpic->pic_type = 2;
801 }
802 }
803 ✗ hpic->pic_order_cnt = pic->display_order - hpic->last_idr_frame;
804
805 ✗ if (priv->aud) {
806 ✗ priv->aud_needed = 1;
807 ✗ priv->raw_aud = (H265RawAUD) {
808 .nal_unit_header = {
809 .nal_unit_type = HEVC_NAL_AUD,
810 .nuh_layer_id = 0,
811 .nuh_temporal_id_plus1 = 1,
812 },
813 ✗ .pic_type = hpic->pic_type,
814 };
815 } else {
816 ✗ priv->aud_needed = 0;
817 }
818
819 ✗ priv->sei_needed = 0;
820
821 // Only look for the metadata on I/IDR frame on the output. We
822 // may force an IDR frame on the output where the medadata gets
823 // changed on the input frame.
824 ✗ if ((priv->sei & SEI_MASTERING_DISPLAY) &&
825 ✗ (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
826 AVFrameSideData *sd =
827 ✗ av_frame_get_side_data(pic->input_image,
828 AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
829
830 ✗ if (sd) {
831 ✗ AVMasteringDisplayMetadata *mdm =
832 (AVMasteringDisplayMetadata *)sd->data;
833
834 // SEI is needed when both the primaries and luminance are set
835 ✗ if (mdm->has_primaries && mdm->has_luminance) {
836 ✗ SEIRawMasteringDisplayColourVolume *mdcv =
837 &priv->sei_mastering_display;
838 ✗ const int mapping[3] = {1, 2, 0};
839 ✗ const int chroma_den = 50000;
840 ✗ const int luma_den = 10000;
841
842 ✗ for (i = 0; i < 3; i++) {
843 ✗ const int j = mapping[i];
844 ✗ mdcv->display_primaries_x[i] =
845 ✗ FFMIN(lrint(chroma_den *
846 av_q2d(mdm->display_primaries[j][0])),
847 chroma_den);
848 ✗ mdcv->display_primaries_y[i] =
849 ✗ FFMIN(lrint(chroma_den *
850 av_q2d(mdm->display_primaries[j][1])),
851 chroma_den);
852 }
853
854 ✗ mdcv->white_point_x =
855 ✗ FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[0])),
856 chroma_den);
857 ✗ mdcv->white_point_y =
858 ✗ FFMIN(lrint(chroma_den * av_q2d(mdm->white_point[1])),
859 chroma_den);
860
861 ✗ mdcv->max_display_mastering_luminance =
862 ✗ lrint(luma_den * av_q2d(mdm->max_luminance));
863 ✗ mdcv->min_display_mastering_luminance =
864 ✗ FFMIN(lrint(luma_den * av_q2d(mdm->min_luminance)),
865 mdcv->max_display_mastering_luminance);
866
867 ✗ priv->sei_needed |= SEI_MASTERING_DISPLAY;
868 }
869 }
870 }
871
872 ✗ if ((priv->sei & SEI_CONTENT_LIGHT_LEVEL) &&
873 ✗ (pic->type == PICTURE_TYPE_I || pic->type == PICTURE_TYPE_IDR)) {
874 AVFrameSideData *sd =
875 ✗ av_frame_get_side_data(pic->input_image,
876 AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);
877
878 ✗ if (sd) {
879 ✗ AVContentLightMetadata *clm =
880 (AVContentLightMetadata *)sd->data;
881 ✗ SEIRawContentLightLevelInfo *clli =
882 &priv->sei_content_light_level;
883
884 ✗ clli->max_content_light_level = FFMIN(clm->MaxCLL, 65535);
885 ✗ clli->max_pic_average_light_level = FFMIN(clm->MaxFALL, 65535);
886
887 ✗ priv->sei_needed |= SEI_CONTENT_LIGHT_LEVEL;
888 }
889 }
890
891 ✗ vpic->decoded_curr_pic = (VAPictureHEVC) {
892 ✗ .picture_id = pic->recon_surface,
893 ✗ .pic_order_cnt = hpic->pic_order_cnt,
894 .flags = 0,
895 };
896
897 ✗ for (i = 0; i < pic->nb_refs; i++) {
898 ✗ VAAPIEncodePicture *ref = pic->refs[i];
899 VAAPIEncodeH265Picture *href;
900
901 ✗ av_assert0(ref && ref->encode_order < pic->encode_order);
902 ✗ href = ref->priv_data;
903
904 ✗ vpic->reference_frames[i] = (VAPictureHEVC) {
905 ✗ .picture_id = ref->recon_surface,
906 ✗ .pic_order_cnt = href->pic_order_cnt,
907 ✗ .flags = (ref->display_order < pic->display_order ?
908 ✗ VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE : 0) |
909 ✗ (ref->display_order > pic->display_order ?
910 ✗ VA_PICTURE_HEVC_RPS_ST_CURR_AFTER : 0),
911 };
912 }
913 ✗ for (; i < FF_ARRAY_ELEMS(vpic->reference_frames); i++) {
914 ✗ vpic->reference_frames[i] = (VAPictureHEVC) {
915 .picture_id = VA_INVALID_ID,
916 .flags = VA_PICTURE_HEVC_INVALID,
917 };
918 }
919
920 ✗ vpic->coded_buf = pic->output_buffer;
921
922 ✗ vpic->nal_unit_type = hpic->slice_nal_unit;
923
924 ✗ switch (pic->type) {
925 ✗ case PICTURE_TYPE_IDR:
926 ✗ vpic->pic_fields.bits.idr_pic_flag = 1;
927 ✗ vpic->pic_fields.bits.coding_type = 1;
928 ✗ vpic->pic_fields.bits.reference_pic_flag = 1;
929 ✗ break;
930 ✗ case PICTURE_TYPE_I:
931 ✗ vpic->pic_fields.bits.idr_pic_flag = 0;
932 ✗ vpic->pic_fields.bits.coding_type = 1;
933 ✗ vpic->pic_fields.bits.reference_pic_flag = 1;
934 ✗ break;
935 ✗ case PICTURE_TYPE_P:
936 ✗ vpic->pic_fields.bits.idr_pic_flag = 0;
937 ✗ vpic->pic_fields.bits.coding_type = 2;
938 ✗ vpic->pic_fields.bits.reference_pic_flag = 1;
939 ✗ break;
940 ✗ case PICTURE_TYPE_B:
941 ✗ vpic->pic_fields.bits.idr_pic_flag = 0;
942 ✗ vpic->pic_fields.bits.coding_type = 3;
943 ✗ vpic->pic_fields.bits.reference_pic_flag = 0;
944 ✗ break;
945 ✗ default:
946 ✗ av_assert0(0 && "invalid picture type");
947 }
948
949 ✗ return 0;
950 }
951
952 ✗ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx,
953 VAAPIEncodePicture *pic,
954 VAAPIEncodeSlice *slice)
955 {
956 ✗ VAAPIEncodeContext *ctx = avctx->priv_data;
957 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
958 ✗ VAAPIEncodeH265Picture *hpic = pic->priv_data;
959 ✗ const H265RawSPS *sps = &priv->raw_sps;
960 ✗ const H265RawPPS *pps = &priv->raw_pps;
961 ✗ H265RawSliceHeader *sh = &priv->raw_slice.header;
962 ✗ VAEncPictureParameterBufferHEVC *vpic = pic->codec_picture_params;
963 ✗ VAEncSliceParameterBufferHEVC *vslice = slice->codec_slice_params;
964 int i;
965
966 ✗ sh->nal_unit_header = (H265RawNALUnitHeader) {
967 ✗ .nal_unit_type = hpic->slice_nal_unit,
968 .nuh_layer_id = 0,
969 .nuh_temporal_id_plus1 = 1,
970 };
971
972 ✗ sh->slice_pic_parameter_set_id = pps->pps_pic_parameter_set_id;
973
974 ✗ sh->first_slice_segment_in_pic_flag = slice->index == 0;
975 ✗ sh->slice_segment_address = slice->block_start;
976
977 ✗ sh->slice_type = hpic->slice_type;
978
979 ✗ if (sh->slice_type == HEVC_SLICE_P && ctx->p_to_gpb)
980 ✗ sh->slice_type = HEVC_SLICE_B;
981
982 ✗ sh->slice_pic_order_cnt_lsb = hpic->pic_order_cnt &
983 ✗ (1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1;
984
985 ✗ if (pic->type != PICTURE_TYPE_IDR) {
986 H265RawSTRefPicSet *rps;
987 const VAAPIEncodeH265Picture *strp;
988 int rps_poc[MAX_DPB_SIZE];
989 int rps_used[MAX_DPB_SIZE];
990 int i, j, poc, rps_pics;
991
992 ✗ sh->short_term_ref_pic_set_sps_flag = 0;
993
994 ✗ rps = &sh->short_term_ref_pic_set;
995 ✗ memset(rps, 0, sizeof(*rps));
996
997 ✗ rps_pics = 0;
998 ✗ for (i = 0; i < pic->nb_refs; i++) {
999 ✗ strp = pic->refs[i]->priv_data;
1000 ✗ rps_poc[rps_pics] = strp->pic_order_cnt;
1001 ✗ rps_used[rps_pics] = 1;
1002 ✗ ++rps_pics;
1003 }
1004 ✗ for (i = 0; i < pic->nb_dpb_pics; i++) {
1005 ✗ if (pic->dpb[i] == pic)
1006 ✗ continue;
1007 ✗ for (j = 0; j < pic->nb_refs; j++) {
1008 ✗ if (pic->dpb[i] == pic->refs[j])
1009 ✗ break;
1010 }
1011 ✗ if (j < pic->nb_refs)
1012 ✗ continue;
1013 ✗ strp = pic->dpb[i]->priv_data;
1014 ✗ rps_poc[rps_pics] = strp->pic_order_cnt;
1015 ✗ rps_used[rps_pics] = 0;
1016 ✗ ++rps_pics;
1017 }
1018
1019 ✗ for (i = 1; i < rps_pics; i++) {
1020 ✗ for (j = i; j > 0; j--) {
1021 ✗ if (rps_poc[j] > rps_poc[j - 1])
1022 ✗ break;
1023 ✗ av_assert0(rps_poc[j] != rps_poc[j - 1]);
1024 ✗ FFSWAP(int, rps_poc[j], rps_poc[j - 1]);
1025 ✗ FFSWAP(int, rps_used[j], rps_used[j - 1]);
1026 }
1027 }
1028
1029 ✗ av_log(avctx, AV_LOG_DEBUG, "RPS for POC %d:",
1030 hpic->pic_order_cnt);
1031 ✗ for (i = 0; i < rps_pics; i++) {
1032 ✗ av_log(avctx, AV_LOG_DEBUG, " (%d,%d)",
1033 rps_poc[i], rps_used[i]);
1034 }
1035 ✗ av_log(avctx, AV_LOG_DEBUG, "\n");
1036
1037 ✗ for (i = 0; i < rps_pics; i++) {
1038 ✗ av_assert0(rps_poc[i] != hpic->pic_order_cnt);
1039 ✗ if (rps_poc[i] > hpic->pic_order_cnt)
1040 ✗ break;
1041 }
1042
1043 ✗ rps->num_negative_pics = i;
1044 ✗ poc = hpic->pic_order_cnt;
1045 ✗ for (j = i - 1; j >= 0; j--) {
1046 ✗ rps->delta_poc_s0_minus1[i - 1 - j] = poc - rps_poc[j] - 1;
1047 ✗ rps->used_by_curr_pic_s0_flag[i - 1 - j] = rps_used[j];
1048 ✗ poc = rps_poc[j];
1049 }
1050
1051 ✗ rps->num_positive_pics = rps_pics - i;
1052 ✗ poc = hpic->pic_order_cnt;
1053 ✗ for (j = i; j < rps_pics; j++) {
1054 ✗ rps->delta_poc_s1_minus1[j - i] = rps_poc[j] - poc - 1;
1055 ✗ rps->used_by_curr_pic_s1_flag[j - i] = rps_used[j];
1056 ✗ poc = rps_poc[j];
1057 }
1058
1059 ✗ sh->num_long_term_sps = 0;
1060 ✗ sh->num_long_term_pics = 0;
1061
1062 // when this flag is not present, it is inerred to 1.
1063 ✗ sh->collocated_from_l0_flag = 1;
1064 ✗ sh->slice_temporal_mvp_enabled_flag =
1065 ✗ sps->sps_temporal_mvp_enabled_flag;
1066 ✗ if (sh->slice_temporal_mvp_enabled_flag) {
1067 ✗ if (sh->slice_type == HEVC_SLICE_B)
1068 ✗ sh->collocated_from_l0_flag = 1;
1069 ✗ sh->collocated_ref_idx = 0;
1070 }
1071
1072 ✗ sh->num_ref_idx_active_override_flag = 0;
1073 ✗ sh->num_ref_idx_l0_active_minus1 = pps->num_ref_idx_l0_default_active_minus1;
1074 ✗ sh->num_ref_idx_l1_active_minus1 = pps->num_ref_idx_l1_default_active_minus1;
1075 }
1076
1077 ✗ sh->slice_sao_luma_flag = sh->slice_sao_chroma_flag =
1078 ✗ sps->sample_adaptive_offset_enabled_flag;
1079
1080 ✗ if (pic->type == PICTURE_TYPE_B)
1081 ✗ sh->slice_qp_delta = priv->fixed_qp_b - (pps->init_qp_minus26 + 26);
1082 ✗ else if (pic->type == PICTURE_TYPE_P)
1083 ✗ sh->slice_qp_delta = priv->fixed_qp_p - (pps->init_qp_minus26 + 26);
1084 else
1085 ✗ sh->slice_qp_delta = priv->fixed_qp_idr - (pps->init_qp_minus26 + 26);
1086
1087
1088 ✗ *vslice = (VAEncSliceParameterBufferHEVC) {
1089 ✗ .slice_segment_address = sh->slice_segment_address,
1090 ✗ .num_ctu_in_slice = slice->block_size,
1091
1092 ✗ .slice_type = sh->slice_type,
1093 ✗ .slice_pic_parameter_set_id = sh->slice_pic_parameter_set_id,
1094
1095 ✗ .num_ref_idx_l0_active_minus1 = sh->num_ref_idx_l0_active_minus1,
1096 ✗ .num_ref_idx_l1_active_minus1 = sh->num_ref_idx_l1_active_minus1,
1097
1098 ✗ .luma_log2_weight_denom = sh->luma_log2_weight_denom,
1099 ✗ .delta_chroma_log2_weight_denom = sh->delta_chroma_log2_weight_denom,
1100
1101 ✗ .max_num_merge_cand = 5 - sh->five_minus_max_num_merge_cand,
1102
1103 ✗ .slice_qp_delta = sh->slice_qp_delta,
1104 ✗ .slice_cb_qp_offset = sh->slice_cb_qp_offset,
1105 ✗ .slice_cr_qp_offset = sh->slice_cr_qp_offset,
1106
1107 ✗ .slice_beta_offset_div2 = sh->slice_beta_offset_div2,
1108 ✗ .slice_tc_offset_div2 = sh->slice_tc_offset_div2,
1109
1110 .slice_fields.bits = {
1111 ✗ .last_slice_of_pic_flag = slice->index == pic->nb_slices - 1,
1112 ✗ .dependent_slice_segment_flag = sh->dependent_slice_segment_flag,
1113 ✗ .colour_plane_id = sh->colour_plane_id,
1114 .slice_temporal_mvp_enabled_flag =
1115 ✗ sh->slice_temporal_mvp_enabled_flag,
1116 ✗ .slice_sao_luma_flag = sh->slice_sao_luma_flag,
1117 ✗ .slice_sao_chroma_flag = sh->slice_sao_chroma_flag,
1118 .num_ref_idx_active_override_flag =
1119 ✗ sh->num_ref_idx_active_override_flag,
1120 ✗ .mvd_l1_zero_flag = sh->mvd_l1_zero_flag,
1121 ✗ .cabac_init_flag = sh->cabac_init_flag,
1122 .slice_deblocking_filter_disabled_flag =
1123 ✗ sh->slice_deblocking_filter_disabled_flag,
1124 .slice_loop_filter_across_slices_enabled_flag =
1125 ✗ sh->slice_loop_filter_across_slices_enabled_flag,
1126 ✗ .collocated_from_l0_flag = sh->collocated_from_l0_flag,
1127 },
1128 };
1129
1130 ✗ for (i = 0; i < FF_ARRAY_ELEMS(vslice->ref_pic_list0); i++) {
1131 ✗ vslice->ref_pic_list0[i].picture_id = VA_INVALID_ID;
1132 ✗ vslice->ref_pic_list0[i].flags = VA_PICTURE_HEVC_INVALID;
1133 ✗ vslice->ref_pic_list1[i].picture_id = VA_INVALID_ID;
1134 ✗ vslice->ref_pic_list1[i].flags = VA_PICTURE_HEVC_INVALID;
1135 }
1136
1137 ✗ av_assert0(pic->nb_refs <= 2);
1138 ✗ if (pic->nb_refs >= 1) {
1139 // Backward reference for P- or B-frame.
1140 ✗ av_assert0(pic->type == PICTURE_TYPE_P ||
1141 pic->type == PICTURE_TYPE_B);
1142 ✗ vslice->ref_pic_list0[0] = vpic->reference_frames[0];
1143 ✗ if (ctx->p_to_gpb && pic->type == PICTURE_TYPE_P)
1144 // Reference for GPB B-frame, L0 == L1
1145 ✗ vslice->ref_pic_list1[0] = vpic->reference_frames[0];
1146 }
1147 ✗ if (pic->nb_refs >= 2) {
1148 // Forward reference for B-frame.
1149 ✗ av_assert0(pic->type == PICTURE_TYPE_B);
1150 ✗ vslice->ref_pic_list1[0] = vpic->reference_frames[1];
1151 }
1152
1153 ✗ if (pic->type == PICTURE_TYPE_P && ctx->p_to_gpb) {
1154 ✗ vslice->slice_type = HEVC_SLICE_B;
1155 ✗ for (i = 0; i < FF_ARRAY_ELEMS(vslice->ref_pic_list0); i++) {
1156 ✗ vslice->ref_pic_list1[i].picture_id = vslice->ref_pic_list0[i].picture_id;
1157 ✗ vslice->ref_pic_list1[i].flags = vslice->ref_pic_list0[i].flags;
1158 }
1159 }
1160
1161 ✗ return 0;
1162 }
1163
1164 ✗ static av_cold int vaapi_encode_h265_get_encoder_caps(AVCodecContext *avctx)
1165 {
1166 ✗ VAAPIEncodeContext *ctx = avctx->priv_data;
1167 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
1168
1169 #if VA_CHECK_VERSION(1, 13, 0)
1170 {
1171 VAConfigAttribValEncHEVCBlockSizes block_size;
1172 VAConfigAttrib attr;
1173 VAStatus vas;
1174
1175 ✗ attr.type = VAConfigAttribEncHEVCFeatures;
1176 ✗ vas = vaGetConfigAttributes(ctx->hwctx->display, ctx->va_profile,
1177 ctx->va_entrypoint, &attr, 1);
1178 ✗ if (vas != VA_STATUS_SUCCESS) {
1179 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to query encoder "
1180 "features, using guessed defaults.\n");
1181 ✗ return AVERROR_EXTERNAL;
1182 ✗ } else if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1183 ✗ av_log(avctx, AV_LOG_WARNING, "Driver does not advertise "
1184 "encoder features, using guessed defaults.\n");
1185 } else {
1186 ✗ priv->va_features = attr.value;
1187 }
1188
1189 ✗ attr.type = VAConfigAttribEncHEVCBlockSizes;
1190 ✗ vas = vaGetConfigAttributes(ctx->hwctx->display, ctx->va_profile,
1191 ctx->va_entrypoint, &attr, 1);
1192 ✗ if (vas != VA_STATUS_SUCCESS) {
1193 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to query encoder "
1194 "block size, using guessed defaults.\n");
1195 ✗ return AVERROR_EXTERNAL;
1196 ✗ } else if (attr.value == VA_ATTRIB_NOT_SUPPORTED) {
1197 ✗ av_log(avctx, AV_LOG_WARNING, "Driver does not advertise "
1198 "encoder block size, using guessed defaults.\n");
1199 } else {
1200 ✗ priv->va_bs = block_size.value = attr.value;
1201
1202 ✗ priv->ctu_size =
1203 ✗ 1 << block_size.bits.log2_max_coding_tree_block_size_minus3 + 3;
1204 ✗ priv->min_cb_size =
1205 ✗ 1 << block_size.bits.log2_min_luma_coding_block_size_minus3 + 3;
1206 }
1207 }
1208 #endif
1209
1210 ✗ if (!priv->ctu_size) {
1211 ✗ priv->ctu_size = 32;
1212 ✗ priv->min_cb_size = 16;
1213 }
1214 ✗ av_log(avctx, AV_LOG_VERBOSE, "Using CTU size %dx%d, "
1215 "min CB size %dx%d.\n", priv->ctu_size, priv->ctu_size,
1216 priv->min_cb_size, priv->min_cb_size);
1217
1218 ✗ ctx->surface_width = FFALIGN(avctx->width, priv->min_cb_size);
1219 ✗ ctx->surface_height = FFALIGN(avctx->height, priv->min_cb_size);
1220
1221 ✗ ctx->slice_block_width = ctx->slice_block_height = priv->ctu_size;
1222
1223 ✗ return 0;
1224 }
1225
1226 ✗ static av_cold int vaapi_encode_h265_configure(AVCodecContext *avctx)
1227 {
1228 ✗ VAAPIEncodeContext *ctx = avctx->priv_data;
1229 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
1230 int err;
1231
1232 ✗ err = ff_cbs_init(&priv->cbc, AV_CODEC_ID_HEVC, avctx);
1233 ✗ if (err < 0)
1234 ✗ return err;
1235
1236 ✗ if (ctx->va_rc_mode == VA_RC_CQP) {
1237 // Note that VAAPI only supports positive QP values - the range is
1238 // therefore always bounded below by 1, even in 10-bit mode where
1239 // it should go down to -12.
1240
1241 ✗ priv->fixed_qp_p = av_clip(ctx->rc_quality, 1, 51);
1242 ✗ if (avctx->i_quant_factor > 0.0)
1243 ✗ priv->fixed_qp_idr =
1244 ✗ av_clip((avctx->i_quant_factor * priv->fixed_qp_p +
1245 ✗ avctx->i_quant_offset) + 0.5, 1, 51);
1246 else
1247 ✗ priv->fixed_qp_idr = priv->fixed_qp_p;
1248 ✗ if (avctx->b_quant_factor > 0.0)
1249 ✗ priv->fixed_qp_b =
1250 ✗ av_clip((avctx->b_quant_factor * priv->fixed_qp_p +
1251 ✗ avctx->b_quant_offset) + 0.5, 1, 51);
1252 else
1253 ✗ priv->fixed_qp_b = priv->fixed_qp_p;
1254
1255 ✗ av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
1256 "%d / %d / %d for IDR- / P- / B-frames.\n",
1257 priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
1258
1259 } else {
1260 // These still need to be set for init_qp/slice_qp_delta.
1261 ✗ priv->fixed_qp_idr = 30;
1262 ✗ priv->fixed_qp_p = 30;
1263 ✗ priv->fixed_qp_b = 30;
1264 }
1265
1266 ✗ ctx->roi_quant_range = 51 + 6 * (ctx->profile->depth - 8);
1267
1268 ✗ return 0;
1269 }
1270
1271 static const VAAPIEncodeProfile vaapi_encode_h265_profiles[] = {
1272 { FF_PROFILE_HEVC_MAIN, 8, 3, 1, 1, VAProfileHEVCMain },
1273 { FF_PROFILE_HEVC_REXT, 8, 3, 1, 1, VAProfileHEVCMain },
1274 #if VA_CHECK_VERSION(0, 37, 0)
1275 { FF_PROFILE_HEVC_MAIN_10, 10, 3, 1, 1, VAProfileHEVCMain10 },
1276 { FF_PROFILE_HEVC_REXT, 10, 3, 1, 1, VAProfileHEVCMain10 },
1277 #endif
1278 #if VA_CHECK_VERSION(1, 2, 0)
1279 { FF_PROFILE_HEVC_REXT, 8, 3, 1, 0, VAProfileHEVCMain422_10 },
1280 { FF_PROFILE_HEVC_REXT, 10, 3, 1, 0, VAProfileHEVCMain422_10 },
1281 #endif
1282 { FF_PROFILE_UNKNOWN }
1283 };
1284
1285 static const VAAPIEncodeType vaapi_encode_type_h265 = {
1286 .profiles = vaapi_encode_h265_profiles,
1287
1288 .flags = FLAG_SLICE_CONTROL |
1289 FLAG_B_PICTURES |
1290 FLAG_B_PICTURE_REFERENCES |
1291 FLAG_NON_IDR_KEY_PICTURES,
1292
1293 .default_quality = 25,
1294
1295 .get_encoder_caps = &vaapi_encode_h265_get_encoder_caps,
1296 .configure = &vaapi_encode_h265_configure,
1297
1298 .picture_priv_data_size = sizeof(VAAPIEncodeH265Picture),
1299
1300 .sequence_params_size = sizeof(VAEncSequenceParameterBufferHEVC),
1301 .init_sequence_params = &vaapi_encode_h265_init_sequence_params,
1302
1303 .picture_params_size = sizeof(VAEncPictureParameterBufferHEVC),
1304 .init_picture_params = &vaapi_encode_h265_init_picture_params,
1305
1306 .slice_params_size = sizeof(VAEncSliceParameterBufferHEVC),
1307 .init_slice_params = &vaapi_encode_h265_init_slice_params,
1308
1309 .sequence_header_type = VAEncPackedHeaderSequence,
1310 .write_sequence_header = &vaapi_encode_h265_write_sequence_header,
1311
1312 .slice_header_type = VAEncPackedHeaderHEVC_Slice,
1313 .write_slice_header = &vaapi_encode_h265_write_slice_header,
1314
1315 .write_extra_header = &vaapi_encode_h265_write_extra_header,
1316 };
1317
1318 ✗ static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx)
1319 {
1320 ✗ VAAPIEncodeContext *ctx = avctx->priv_data;
1321 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
1322
1323 ✗ ctx->codec = &vaapi_encode_type_h265;
1324
1325 ✗ if (avctx->profile == FF_PROFILE_UNKNOWN)
1326 ✗ avctx->profile = priv->profile;
1327 ✗ if (avctx->level == FF_LEVEL_UNKNOWN)
1328 ✗ avctx->level = priv->level;
1329
1330 ✗ if (avctx->level != FF_LEVEL_UNKNOWN && avctx->level & ~0xff) {
1331 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid level %d: must fit "
1332 "in 8-bit unsigned integer.\n", avctx->level);
1333 ✗ return AVERROR(EINVAL);
1334 }
1335
1336 ✗ ctx->desired_packed_headers =
1337 VA_ENC_PACKED_HEADER_SEQUENCE | // VPS, SPS and PPS.
1338 VA_ENC_PACKED_HEADER_SLICE | // Slice headers.
1339 VA_ENC_PACKED_HEADER_MISC; // SEI
1340
1341 ✗ if (priv->qp > 0)
1342 ✗ ctx->explicit_qp = priv->qp;
1343
1344 ✗ return ff_vaapi_encode_init(avctx);
1345 }
1346
1347 ✗ static av_cold int vaapi_encode_h265_close(AVCodecContext *avctx)
1348 {
1349 ✗ VAAPIEncodeH265Context *priv = avctx->priv_data;
1350
1351 ✗ ff_cbs_fragment_free(&priv->current_access_unit);
1352 ✗ ff_cbs_close(&priv->cbc);
1353
1354 ✗ return ff_vaapi_encode_close(avctx);
1355 }
1356
1357 #define OFFSET(x) offsetof(VAAPIEncodeH265Context, x)
1358 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
1359 static const AVOption vaapi_encode_h265_options[] = {
1360 VAAPI_ENCODE_COMMON_OPTIONS,
1361 VAAPI_ENCODE_RC_OPTIONS,
1362
1363 { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)",
1364 OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, FLAGS },
1365
1366 { "aud", "Include AUD",
1367 OFFSET(aud), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1368
1369 { "profile", "Set profile (general_profile_idc)",
1370 OFFSET(profile), AV_OPT_TYPE_INT,
1371 { .i64 = FF_PROFILE_UNKNOWN }, FF_PROFILE_UNKNOWN, 0xff, FLAGS, "profile" },
1372
1373 #define PROFILE(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1374 { .i64 = value }, 0, 0, FLAGS, "profile"
1375 { PROFILE("main", FF_PROFILE_HEVC_MAIN) },
1376 { PROFILE("main10", FF_PROFILE_HEVC_MAIN_10) },
1377 { PROFILE("rext", FF_PROFILE_HEVC_REXT) },
1378 #undef PROFILE
1379
1380 { "tier", "Set tier (general_tier_flag)",
1381 OFFSET(tier), AV_OPT_TYPE_INT,
1382 { .i64 = 0 }, 0, 1, FLAGS, "tier" },
1383 { "main", NULL, 0, AV_OPT_TYPE_CONST,
1384 { .i64 = 0 }, 0, 0, FLAGS, "tier" },
1385 { "high", NULL, 0, AV_OPT_TYPE_CONST,
1386 { .i64 = 1 }, 0, 0, FLAGS, "tier" },
1387
1388 { "level", "Set level (general_level_idc)",
1389 OFFSET(level), AV_OPT_TYPE_INT,
1390 { .i64 = FF_LEVEL_UNKNOWN }, FF_LEVEL_UNKNOWN, 0xff, FLAGS, "level" },
1391
1392 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
1393 { .i64 = value }, 0, 0, FLAGS, "level"
1394 { LEVEL("1", 30) },
1395 { LEVEL("2", 60) },
1396 { LEVEL("2.1", 63) },
1397 { LEVEL("3", 90) },
1398 { LEVEL("3.1", 93) },
1399 { LEVEL("4", 120) },
1400 { LEVEL("4.1", 123) },
1401 { LEVEL("5", 150) },
1402 { LEVEL("5.1", 153) },
1403 { LEVEL("5.2", 156) },
1404 { LEVEL("6", 180) },
1405 { LEVEL("6.1", 183) },
1406 { LEVEL("6.2", 186) },
1407 #undef LEVEL
1408
1409 { "sei", "Set SEI to include",
1410 OFFSET(sei), AV_OPT_TYPE_FLAGS,
1411 { .i64 = SEI_MASTERING_DISPLAY | SEI_CONTENT_LIGHT_LEVEL },
1412 0, INT_MAX, FLAGS, "sei" },
1413 { "hdr",
1414 "Include HDR metadata for mastering display colour volume "
1415 "and content light level information",
1416 0, AV_OPT_TYPE_CONST,
1417 { .i64 = SEI_MASTERING_DISPLAY | SEI_CONTENT_LIGHT_LEVEL },
1418 INT_MIN, INT_MAX, FLAGS, "sei" },
1419
1420 { "tiles", "Tile columns x rows",
1421 OFFSET(common.tile_cols), AV_OPT_TYPE_IMAGE_SIZE,
1422 { .str = NULL }, 0, 0, FLAGS },
1423
1424 { NULL },
1425 };
1426
1427 static const FFCodecDefault vaapi_encode_h265_defaults[] = {
1428 { "b", "0" },
1429 { "bf", "2" },
1430 { "g", "120" },
1431 { "i_qfactor", "1" },
1432 { "i_qoffset", "0" },
1433 { "b_qfactor", "6/5" },
1434 { "b_qoffset", "0" },
1435 { "qmin", "-1" },
1436 { "qmax", "-1" },
1437 { NULL },
1438 };
1439
1440 static const AVClass vaapi_encode_h265_class = {
1441 .class_name = "h265_vaapi",
1442 .item_name = av_default_item_name,
1443 .option = vaapi_encode_h265_options,
1444 .version = LIBAVUTIL_VERSION_INT,
1445 };
1446
1447 const FFCodec ff_hevc_vaapi_encoder = {
1448 .p.name = "hevc_vaapi",
1449 .p.long_name = NULL_IF_CONFIG_SMALL("H.265/HEVC (VAAPI)"),
1450 .p.type = AVMEDIA_TYPE_VIDEO,
1451 .p.id = AV_CODEC_ID_HEVC,
1452 .priv_data_size = sizeof(VAAPIEncodeH265Context),
1453 .init = &vaapi_encode_h265_init,
1454 FF_CODEC_RECEIVE_PACKET_CB(&ff_vaapi_encode_receive_packet),
1455 .close = &vaapi_encode_h265_close,
1456 .p.priv_class = &vaapi_encode_h265_class,
1457 .p.capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE |
1458 AV_CODEC_CAP_DR1,
1459 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1460 .defaults = vaapi_encode_h265_defaults,
1461 .p.pix_fmts = (const enum AVPixelFormat[]) {
1462 AV_PIX_FMT_VAAPI,
1463 AV_PIX_FMT_NONE,
1464 },
1465 .hw_configs = ff_vaapi_encode_hw_configs,
1466 .p.wrapper_name = "vaapi",
1467 };
1468