1 /**************************************************************************
2 *
3 * Copyright 2023 Advanced Micro Devices, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 #include "util/u_handle_table.h"
29 #include "util/u_video.h"
30 #include "va_private.h"
31 #include "util/vl_vlc.h"
32
33 #if VA_CHECK_VERSION(1, 16, 0)
34
35 #define AV1_SELECT_SCREEN_CONTENT_TOOLS (2)
36 #define AV1_SELECT_INTEGER_MV (2)
37 #define AV1_PRIMARY_REF_NON (7)
38 #define AV1_MAXNUM_OPERATING_POINT (32)
39 #define AV1_SUPERRES_DENOM_BITS (8)
40 #define AV1_MAXNUM_REF_FRAMES (8)
41 #define AV1_REFS_PER_FRAME (7)
42 #define FRAME_TYPE_KEY_FRAME (0)
43 #define FRAME_TYPE_INTER_FRAME (1)
44 #define FRAME_TYPE_INTRA_ONLY (2)
45 #define FRAME_TYPE_SWITCH (3)
46 #define OBU_TYPE_SEQUENCE_HEADER (1)
47 #define OBU_TYPE_FRAME_HEADER (3)
48 #define OBU_TYPE_FRAME (6)
49 #define AV1_MIN_QP_DEFAULT (1)
50 #define AV1_MAX_QP_DEFAULT (255)
51
av1_f(struct vl_vlc * vlc,unsigned n)52 static unsigned av1_f(struct vl_vlc *vlc, unsigned n)
53 {
54 unsigned valid = vl_vlc_valid_bits(vlc);
55
56 if (n == 0)
57 return 0;
58
59 if (valid < 32)
60 vl_vlc_fillbits(vlc);
61
62 return vl_vlc_get_uimsbf(vlc, n);
63 }
64
av1_uvlc(struct vl_vlc * vlc)65 static unsigned av1_uvlc(struct vl_vlc *vlc)
66 {
67 unsigned value;
68 unsigned leadingZeros = 0;
69
70 while (1) {
71 bool done = av1_f(vlc, 1);
72 if (done)
73 break;
74 leadingZeros++;
75 }
76
77 if (leadingZeros >= 32)
78 return 0xffffffff;
79
80 value = av1_f(vlc, leadingZeros);
81
82 return value + (1 << leadingZeros) - 1;
83 }
84
av1_uleb128(struct vl_vlc * vlc)85 static unsigned av1_uleb128(struct vl_vlc *vlc)
86 {
87 unsigned value = 0;
88 unsigned leb128Bytes = 0;
89 unsigned i;
90
91 for (i = 0; i < 8; ++i) {
92 leb128Bytes = av1_f(vlc, 8);
93 value |= ((leb128Bytes & 0x7f) << (i * 7));
94 if (!(leb128Bytes & 0x80))
95 break;
96 }
97
98 return value;
99 }
100
vlVaHandleVAEncSequenceParameterBufferTypeAV1(vlVaDriver * drv,vlVaContext * context,vlVaBuffer * buf)101 VAStatus vlVaHandleVAEncSequenceParameterBufferTypeAV1(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
102 {
103 VAEncSequenceParameterBufferAV1 *av1 = buf->data;
104
105 if (!context->decoder) {
106 context->templat.max_references = PIPE_AV1_MAX_REFERENCES;
107 context->templat.level = av1->seq_level_idx;
108 context->decoder = drv->pipe->create_video_codec(drv->pipe, &context->templat);
109
110 if (!context->decoder)
111 return VA_STATUS_ERROR_ALLOCATION_FAILED;
112
113 getEncParamPresetAV1(context);
114 context->desc.av1enc.intra_refresh.mode = INTRA_REFRESH_MODE_NONE;
115 context->desc.av1enc.intra_refresh.offset = 0;
116 context->desc.av1enc.intra_refresh.region_size = 0;
117 context->desc.av1enc.intra_refresh.need_sequence_header = 0;
118 }
119
120 context->desc.av1enc.seq.tier = av1->seq_tier;
121 context->desc.av1enc.seq.level = av1->seq_level_idx;
122 context->desc.av1enc.seq.intra_period = av1->intra_period;
123 context->desc.av1enc.seq.ip_period = av1->ip_period;
124 context->desc.av1enc.seq.bit_depth_minus8 = av1->seq_fields.bits.bit_depth_minus8;
125 context->desc.av1enc.seq.seq_bits.enable_cdef = av1->seq_fields.bits.enable_cdef;
126 context->desc.av1enc.seq.seq_bits.enable_order_hint = av1->seq_fields.bits.enable_order_hint;
127
128 for (int i = 0; i < ARRAY_SIZE(context->desc.av1enc.rc); i++)
129 context->desc.av1enc.rc[i].peak_bitrate = av1->bits_per_second;
130
131 return VA_STATUS_SUCCESS;
132 }
vlVaHandleVAEncPictureParameterBufferTypeAV1(vlVaDriver * drv,vlVaContext * context,vlVaBuffer * buf)133 VAStatus vlVaHandleVAEncPictureParameterBufferTypeAV1(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
134 {
135 VAEncPictureParameterBufferAV1 *av1 = buf->data;
136 struct pipe_video_buffer *video_buf = NULL;
137 vlVaBuffer *coded_buf;
138 int i;
139
140 context->desc.av1enc.disable_frame_end_update_cdf = av1->picture_flags.bits.disable_frame_end_update_cdf;
141 context->desc.av1enc.error_resilient_mode = av1->picture_flags.bits.error_resilient_mode;
142 context->desc.av1enc.disable_cdf_update = av1->picture_flags.bits.disable_cdf_update;
143 context->desc.av1enc.enable_frame_obu = av1->picture_flags.bits.enable_frame_obu;
144 context->desc.av1enc.allow_high_precision_mv = av1->picture_flags.bits.allow_high_precision_mv;
145 context->desc.av1enc.palette_mode_enable = av1->picture_flags.bits.palette_mode_enable;
146 context->desc.av1enc.long_term_reference = av1->picture_flags.bits.long_term_reference;
147 context->desc.av1enc.num_tiles_in_pic = av1->tile_cols * av1->tile_rows;
148 context->desc.av1enc.tile_rows = av1->tile_rows;
149 context->desc.av1enc.tile_cols = av1->tile_cols;
150 context->desc.av1enc.context_update_tile_id = av1->context_update_tile_id;
151 context->desc.av1enc.use_superres = av1->picture_flags.bits.use_superres;
152 context->desc.av1enc.reduced_tx_set = av1->picture_flags.bits.reduced_tx_set;
153 context->desc.av1enc.skip_mode_present = av1->mode_control_flags.bits.skip_mode_present;
154 context->desc.av1enc.tx_mode = av1->mode_control_flags.bits.tx_mode;
155 context->desc.av1enc.compound_reference_mode = av1->mode_control_flags.bits.reference_mode;
156 context->desc.av1enc.superres_scale_denominator = av1->superres_scale_denominator;
157 context->desc.av1enc.interpolation_filter = av1->interpolation_filter;
158
159 /* The last tile column or row size needs to be derived. */
160 for (uint8_t i = 0 ; i < ARRAY_SIZE(av1->width_in_sbs_minus_1); i++)
161 context->desc.av1enc.width_in_sbs_minus_1[i] = av1->width_in_sbs_minus_1[i];
162
163 /* The last tile column or row size needs to be derived. */
164 for (uint8_t i = 0 ; i < ARRAY_SIZE(av1->height_in_sbs_minus_1); i++)
165 context->desc.av1enc.height_in_sbs_minus_1[i] = av1->height_in_sbs_minus_1[i];
166
167 context->desc.av1enc.cdef.cdef_damping_minus_3 = av1->cdef_damping_minus_3;
168 context->desc.av1enc.cdef.cdef_bits = av1->cdef_bits;
169
170 for (uint8_t i = 0 ; i < ARRAY_SIZE(av1->cdef_y_strengths); i++)
171 context->desc.av1enc.cdef.cdef_y_strengths[i] = av1->cdef_y_strengths[i];
172
173 for (uint8_t i = 0 ; i < ARRAY_SIZE(av1->cdef_uv_strengths); i++)
174 context->desc.av1enc.cdef.cdef_uv_strengths[i] = av1->cdef_uv_strengths[i];
175
176 context->desc.av1enc.loop_filter.filter_level[0] = av1->filter_level[0];
177 context->desc.av1enc.loop_filter.filter_level[1] = av1->filter_level[1];
178 context->desc.av1enc.loop_filter.filter_level_u = av1->filter_level_u;
179 context->desc.av1enc.loop_filter.filter_level_v = av1->filter_level_v;
180 context->desc.av1enc.loop_filter.sharpness_level = av1->loop_filter_flags.bits.sharpness_level;
181 context->desc.av1enc.loop_filter.mode_ref_delta_enabled = av1->loop_filter_flags.bits.mode_ref_delta_enabled;
182 context->desc.av1enc.loop_filter.mode_ref_delta_update = av1->loop_filter_flags.bits.mode_ref_delta_update;
183 context->desc.av1enc.loop_filter.delta_lf_present = av1->mode_control_flags.bits.delta_lf_present;
184 context->desc.av1enc.loop_filter.delta_lf_res = av1->mode_control_flags.bits.delta_lf_res;
185 context->desc.av1enc.loop_filter.delta_lf_multi = av1->mode_control_flags.bits.delta_lf_multi;
186
187 context->desc.av1enc.restoration.yframe_restoration_type = av1->loop_restoration_flags.bits.yframe_restoration_type;
188 context->desc.av1enc.restoration.cbframe_restoration_type = av1->loop_restoration_flags.bits.cbframe_restoration_type;
189 context->desc.av1enc.restoration.crframe_restoration_type = av1->loop_restoration_flags.bits.crframe_restoration_type;
190 context->desc.av1enc.restoration.lr_unit_shift = av1->loop_restoration_flags.bits.lr_unit_shift;
191 context->desc.av1enc.restoration.lr_uv_shift = av1->loop_restoration_flags.bits.lr_uv_shift;
192 context->desc.av1enc.quantization.base_qindex = av1->base_qindex;
193 context->desc.av1enc.quantization.y_dc_delta_q = av1->y_dc_delta_q;
194 context->desc.av1enc.quantization.u_dc_delta_q = av1->u_dc_delta_q;
195 context->desc.av1enc.quantization.u_ac_delta_q = av1->u_ac_delta_q;
196 context->desc.av1enc.quantization.v_dc_delta_q = av1->v_dc_delta_q;
197 context->desc.av1enc.quantization.v_ac_delta_q = av1->v_ac_delta_q;
198 context->desc.av1enc.quantization.min_base_qindex = av1->min_base_qindex;
199 context->desc.av1enc.quantization.max_base_qindex = av1->max_base_qindex;
200 context->desc.av1enc.quantization.using_qmatrix = av1->qmatrix_flags.bits.using_qmatrix;
201 context->desc.av1enc.quantization.qm_y = av1->qmatrix_flags.bits.qm_y;
202 context->desc.av1enc.quantization.qm_u = av1->qmatrix_flags.bits.qm_u;
203 context->desc.av1enc.quantization.qm_v = av1->qmatrix_flags.bits.qm_v;
204 context->desc.av1enc.quantization.delta_q_present = av1->mode_control_flags.bits.delta_q_present;
205 context->desc.av1enc.quantization.delta_q_res = av1->mode_control_flags.bits.delta_q_res;
206
207 /* VAEncWarpedMotionParamsAV1 wm[7]; */
208
209 context->desc.av1enc.tg_obu_header.obu_extension_flag = av1->tile_group_obu_hdr_info.bits.obu_extension_flag;
210 context->desc.av1enc.tg_obu_header.obu_has_size_field = av1->tile_group_obu_hdr_info.bits.obu_has_size_field;
211 context->desc.av1enc.tg_obu_header.obu_has_size_field = av1->tile_group_obu_hdr_info.bits.obu_has_size_field;
212 context->desc.av1enc.tg_obu_header.temporal_id = av1->tile_group_obu_hdr_info.bits.temporal_id;
213 context->desc.av1enc.tg_obu_header.spatial_id = av1->tile_group_obu_hdr_info.bits.spatial_id;
214
215 coded_buf = handle_table_get(drv->htab, av1->coded_buf);
216 if (!coded_buf)
217 return VA_STATUS_ERROR_INVALID_BUFFER;
218
219 if (!coded_buf->derived_surface.resource)
220 coded_buf->derived_surface.resource = pipe_buffer_create(drv->pipe->screen, PIPE_BIND_VERTEX_BUFFER,
221 PIPE_USAGE_STAGING, coded_buf->size);
222 context->coded_buf = coded_buf;
223
224 for (i = 0; i < ARRAY_SIZE(context->desc.av1enc.rc); i++) {
225 context->desc.av1enc.rc[i].qp = av1->base_qindex ? av1->base_qindex : 60;
226 /* Distinguishes from the default params set for these values and app specific params passed down */
227 context->desc.av1enc.rc[i].app_requested_initial_qp = (av1->base_qindex != 0);
228 context->desc.av1enc.rc[i].min_qp = av1->min_base_qindex ? av1->min_base_qindex : 1;
229 context->desc.av1enc.rc[i].max_qp = av1->max_base_qindex ? av1->max_base_qindex : 255;
230 /* Distinguishes from the default params set for these values and app specific params passed down */
231 context->desc.av1enc.rc[i].app_requested_qp_range =
232 ((context->desc.av1enc.rc[i].max_qp != AV1_MAX_QP_DEFAULT) || (context->desc.av1enc.rc[i].min_qp != AV1_MIN_QP_DEFAULT));
233 }
234
235 /* these frame types will need to be seen as force type */
236 switch(av1->picture_flags.bits.frame_type)
237 {
238 case 0:
239 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_KEY;
240 break;
241 case 1:
242 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_INTER;
243 break;
244 case 2:
245 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_INTRA_ONLY;
246 break;
247 case 3:
248 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_SWITCH;
249 break;
250 };
251
252 if (context->desc.av1enc.frame_type == FRAME_TYPE_KEY_FRAME)
253 context->desc.av1enc.last_key_frame_num = context->desc.av1enc.frame_num;
254
255 if (av1->reconstructed_frame != VA_INVALID_ID) {
256 vlVaGetReferenceFrame(drv, av1->reconstructed_frame, &video_buf);
257 context->desc.av1enc.recon_frame = video_buf;
258 }
259 else
260 context->desc.av1enc.recon_frame = NULL;
261
262 for (int i = 0 ; i < ARRAY_SIZE(context->desc.av1enc.ref_list); i++) {
263 if (av1->reference_frames[i] != VA_INVALID_ID) {
264 vlVaGetReferenceFrame(drv, av1->reference_frames[i], &video_buf);
265 context->desc.av1enc.ref_list[i] = video_buf;
266 }
267 else
268 context->desc.av1enc.ref_list[i] = NULL;
269 }
270
271 context->desc.av1enc.ref_frame_ctrl_l0 = av1->ref_frame_ctrl_l0.value;
272
273 for (int i = 0 ; i < ARRAY_SIZE(av1->ref_frame_idx); i++)
274 context->desc.av1enc.ref_frame_idx[i] = av1->ref_frame_idx[i];
275
276 /* Initialize slice descriptors for this picture */
277 context->desc.av1enc.num_tile_groups = 0;
278 memset(&context->desc.av1enc.tile_groups, 0, sizeof(context->desc.av1enc.tile_groups));
279
280 return VA_STATUS_SUCCESS;
281 }
282
vlVaHandleVAEncMiscParameterTypeRateControlAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)283 VAStatus vlVaHandleVAEncMiscParameterTypeRateControlAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
284 {
285 unsigned temporal_id;
286 VAEncMiscParameterRateControl *rc = (VAEncMiscParameterRateControl *)misc->data;
287 struct pipe_av1_enc_rate_control *pipe_rc = NULL;
288
289 temporal_id = context->desc.av1enc.rc[0].rate_ctrl_method !=
290 PIPE_H2645_ENC_RATE_CONTROL_METHOD_DISABLE ?
291 rc->rc_flags.bits.temporal_id :
292 0;
293
294 if (context->desc.av1enc.seq.num_temporal_layers > 0 &&
295 temporal_id >= context->desc.av1enc.seq.num_temporal_layers)
296 return VA_STATUS_ERROR_INVALID_PARAMETER;
297
298 pipe_rc = &context->desc.av1enc.rc[temporal_id];
299
300 if (pipe_rc->rate_ctrl_method == PIPE_H2645_ENC_RATE_CONTROL_METHOD_CONSTANT)
301 pipe_rc->target_bitrate = rc->bits_per_second;
302 else
303 pipe_rc->target_bitrate = rc->bits_per_second * (rc->target_percentage / 100.0);
304 pipe_rc->peak_bitrate = rc->bits_per_second;
305 if (pipe_rc->target_bitrate < 2000000)
306 pipe_rc->vbv_buffer_size = MIN2((pipe_rc->target_bitrate * 2.75), 2000000);
307 else
308 pipe_rc->vbv_buffer_size = pipe_rc->target_bitrate;
309
310 pipe_rc->fill_data_enable = !(rc->rc_flags.bits.disable_bit_stuffing);
311 pipe_rc->skip_frame_enable = 0;/* !(rc->rc_flags.bits.disable_frame_skip); */
312 pipe_rc->max_qp = rc->max_qp;
313 pipe_rc->min_qp = rc->min_qp;
314 /* Distinguishes from the default params set for these values in other
315 functions and app specific params passed down */
316 pipe_rc->app_requested_qp_range = ((rc->max_qp > 0) || (rc->min_qp > 0));
317
318 if (pipe_rc->rate_ctrl_method == PIPE_H2645_ENC_RATE_CONTROL_METHOD_QUALITY_VARIABLE)
319 pipe_rc->vbr_quality_factor = rc->quality_factor;
320
321 return VA_STATUS_SUCCESS;
322 }
323
324 VAStatus
vlVaHandleVAEncMiscParameterTypeQualityLevelAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)325 vlVaHandleVAEncMiscParameterTypeQualityLevelAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
326 {
327 VAEncMiscParameterBufferQualityLevel *ql = (VAEncMiscParameterBufferQualityLevel *)misc->data;
328 vlVaHandleVAEncMiscParameterTypeQualityLevel(&context->desc.av1enc.quality_modes,
329 (vlVaQualityBits *)&ql->quality_level);
330
331 return VA_STATUS_SUCCESS;
332 }
333
334 VAStatus
vlVaHandleVAEncMiscParameterTypeMaxFrameSizeAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)335 vlVaHandleVAEncMiscParameterTypeMaxFrameSizeAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
336 {
337 VAEncMiscParameterBufferMaxFrameSize *ms = (VAEncMiscParameterBufferMaxFrameSize *)misc->data;
338 context->desc.av1enc.rc[0].max_au_size = ms->max_frame_size;
339 return VA_STATUS_SUCCESS;
340 }
341
342 VAStatus
vlVaHandleVAEncMiscParameterTypeHRDAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)343 vlVaHandleVAEncMiscParameterTypeHRDAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
344 {
345 VAEncMiscParameterHRD *ms = (VAEncMiscParameterHRD *)misc->data;
346
347 if (ms->buffer_size) {
348 context->desc.av1enc.rc[0].vbv_buffer_size = ms->buffer_size;
349 context->desc.av1enc.rc[0].vbv_buf_lv = (ms->initial_buffer_fullness << 6 ) / ms->buffer_size;
350 context->desc.av1enc.rc[0].vbv_buf_initial_size = ms->initial_buffer_fullness;
351 /* Distinguishes from the default params set for these values in other
352 * functions and app specific params passed down via HRD buffer */
353 context->desc.av1enc.rc[0].app_requested_hrd_buffer = true;
354 }
355
356 return VA_STATUS_SUCCESS;
357 }
358
av1_color_config(vlVaContext * context,struct vl_vlc * vlc)359 static void av1_color_config(vlVaContext *context, struct vl_vlc *vlc)
360 {
361 unsigned high_bitdepth = 0;
362 unsigned bit_depth = 8;
363 unsigned mono_chrome = 0;
364 unsigned subsampling_x = 0, subsampling_y = 0;
365
366 struct pipe_av1_enc_seq_param *seq = &context->desc.av1enc.seq;
367
368 high_bitdepth = av1_f(vlc, 1);
369 if (seq->profile == 2 && high_bitdepth) {
370 unsigned twelve_bit = av1_f(vlc, 1);
371 bit_depth = twelve_bit ? 12 : 10;
372 } else if (seq->profile <= 2)
373 bit_depth = high_bitdepth ? 10 : 8;
374
375 context->desc.av1enc.seq.bit_depth_minus8 = bit_depth - 8;
376
377 if (seq->profile == 1)
378 mono_chrome = 0;
379 else
380 mono_chrome = av1_f(vlc, 1);
381
382 seq->seq_bits.color_description_present_flag = av1_f(vlc, 1);
383 if (seq->seq_bits.color_description_present_flag) {
384 seq->color_config.color_primaries = av1_f(vlc, 8);
385 seq->color_config.transfer_characteristics = av1_f(vlc, 8);
386 seq->color_config.matrix_coefficients = av1_f(vlc, 8);
387 } else {
388 seq->color_config.color_primaries = 2;
389 seq->color_config.transfer_characteristics = 2;
390 seq->color_config.matrix_coefficients = 2;
391 }
392
393 if (mono_chrome) {
394 seq->color_config.color_range = av1_f(vlc, 1);
395 subsampling_x = subsampling_y = 1;
396 seq->color_config.chroma_sample_position = 0;
397 return;
398 } else if (seq->color_config.color_primaries == 1 && /* CP_BT_709 */
399 seq->color_config.transfer_characteristics == 13 && /* TC_SRGB */
400 seq->color_config.matrix_coefficients == 0) { /* MC_IDENTITY */
401 seq->color_config.color_range = 1;
402 subsampling_x = subsampling_y = 0;
403 } else {
404 seq->color_config.color_range = av1_f(vlc, 1);
405 if (seq->profile == 0)
406 subsampling_x = subsampling_y = 1;
407 else if (seq->profile == 1)
408 subsampling_x = subsampling_y = 0;
409 else {
410 if (bit_depth == 12) {
411 subsampling_x = av1_f(vlc, 1);
412 if (subsampling_x)
413 subsampling_y = av1_f(vlc, 1);
414 else
415 subsampling_y = 0;
416 }
417 }
418 if (subsampling_x && subsampling_y)
419 seq->color_config.chroma_sample_position = av1_f(vlc, 2);
420 }
421
422 av1_f(vlc, 1);
423 }
424
av1_sequence_header(vlVaContext * context,struct vl_vlc * vlc)425 static void av1_sequence_header(vlVaContext *context, struct vl_vlc *vlc)
426 {
427 unsigned initial_display_delay_present_flag = 0;
428 unsigned layer_minus1 = 0, value = 0;
429 unsigned buffer_delay_length_minus1 = 0;
430 unsigned still_pic = 0;
431 struct pipe_av1_enc_seq_param *seq = &context->desc.av1enc.seq;
432
433 seq->profile = av1_f(vlc, 3);
434 still_pic = av1_f(vlc, 1);
435 av1_f(vlc, 1);
436 assert(!still_pic);
437
438 seq->seq_bits.timing_info_present_flag = av1_f(vlc, 1);
439 if (seq->seq_bits.timing_info_present_flag) {
440 seq->num_units_in_display_tick = av1_f(vlc, 32);
441 seq->time_scale = av1_f(vlc, 32);
442 seq->seq_bits.equal_picture_interval = av1_f(vlc, 1);
443 if (seq->seq_bits.equal_picture_interval)
444 seq->num_tick_per_picture_minus1 = av1_uvlc(vlc);
445 seq->seq_bits.decoder_model_info_present_flag = av1_f(vlc, 1);
446 if (seq->seq_bits.decoder_model_info_present_flag) {
447 struct pipe_av1_enc_decoder_model_info *info = &seq->decoder_model_info;
448 info->buffer_delay_length_minus1 = av1_f(vlc, 5);
449 info->num_units_in_decoding_tick = av1_f(vlc, 32);
450 info->buffer_removal_time_length_minus1 = av1_f(vlc, 5);
451 info->frame_presentation_time_length_minus1 = av1_f(vlc, 5);
452 }
453 }
454 initial_display_delay_present_flag = av1_f(vlc, 1);
455 layer_minus1 = av1_f(vlc, 5);
456 seq->num_temporal_layers = layer_minus1 + 1;
457 for (unsigned i = 0; i <= layer_minus1; i++) {
458 seq->operating_point_idc[i] = av1_f(vlc, 12);
459 value = av1_f(vlc, 5);
460 if (value > 7)
461 av1_f(vlc, 1);
462 if (seq->seq_bits.decoder_model_info_present_flag) {
463 seq->decoder_model_present_for_this_op[i] = av1_f(vlc, 1);
464 if (seq->decoder_model_present_for_this_op[i]) {
465 av1_f(vlc, buffer_delay_length_minus1 + 1);
466 av1_f(vlc, buffer_delay_length_minus1 + 1);
467 av1_f(vlc, 1);
468 } else
469 seq->decoder_model_present_for_this_op[i] = 0;
470 }
471 if (initial_display_delay_present_flag) {
472 value = av1_f(vlc, 1);
473 if (value)
474 av1_f(vlc, 4);
475 }
476 }
477 seq->frame_width_bits_minus1 = av1_f(vlc, 4);
478 seq->frame_height_bits_minus1 = av1_f(vlc, 4);
479 seq->pic_width_in_luma_samples = av1_f(vlc, seq->frame_width_bits_minus1 + 1) + 1;
480 seq->pic_height_in_luma_samples = av1_f(vlc, seq->frame_height_bits_minus1 + 1) + 1;
481 seq->seq_bits.frame_id_number_present_flag = av1_f(vlc, 1);
482 if (seq->seq_bits.frame_id_number_present_flag) {
483 seq->delta_frame_id_length = av1_f(vlc, 4) + 2;
484 seq->additional_frame_id_length = av1_f(vlc, 3) + 1;
485 }
486 seq->seq_bits.use_128x128_superblock = av1_f(vlc, 1);
487 seq->seq_bits.enable_filter_intra = av1_f(vlc, 1);
488 seq->seq_bits.enable_intra_edge_filter = av1_f(vlc, 1);
489 /* reduced_still_pictuer_header should be zero */
490 seq->seq_bits.enable_interintra_compound = av1_f(vlc, 1);
491 seq->seq_bits.enable_masked_compound = av1_f(vlc, 1);
492 seq->seq_bits.enable_warped_motion = av1_f(vlc, 1);
493 seq->seq_bits.enable_dual_filter = av1_f(vlc, 1);
494 seq->seq_bits.enable_order_hint = av1_f(vlc, 1);
495 if (seq->seq_bits.enable_order_hint) {
496 seq->seq_bits.enable_jnt_comp = av1_f(vlc, 1);
497 seq->seq_bits.enable_ref_frame_mvs = av1_f(vlc, 1);
498 } else
499 seq->seq_bits.enable_ref_frame_mvs = 0;
500
501 seq->seq_bits.disable_screen_content_tools = av1_f(vlc, 1);
502 if (seq->seq_bits.disable_screen_content_tools)
503 seq->seq_bits.force_screen_content_tools = AV1_SELECT_SCREEN_CONTENT_TOOLS;
504 else
505 seq->seq_bits.force_screen_content_tools = av1_f(vlc, 1);
506
507 seq->seq_bits.force_integer_mv = AV1_SELECT_INTEGER_MV;
508 if (seq->seq_bits.force_screen_content_tools) {
509 value = av1_f(vlc, 1);
510 if (!value)
511 seq->seq_bits.force_integer_mv = av1_f(vlc, 1);
512 }
513 if (seq->seq_bits.enable_order_hint)
514 seq->order_hint_bits = av1_f(vlc, 3) + 1;
515 else
516 seq->order_hint_bits = 0;
517
518 seq->seq_bits.enable_superres = av1_f(vlc, 1);
519 seq->seq_bits.enable_cdef = av1_f(vlc, 1);
520 seq->seq_bits.enable_restoration = av1_f(vlc, 1);
521 av1_color_config(context, vlc);
522 }
523
av1_superres_params(vlVaContext * context,struct vl_vlc * vlc)524 static void av1_superres_params(vlVaContext *context, struct vl_vlc *vlc)
525 {
526 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
527 uint8_t use_superres;
528
529 if (av1->seq.seq_bits.enable_superres)
530 use_superres = av1_f(vlc, 1);
531 else
532 use_superres = 0;
533
534 if (use_superres)
535 av1_f(vlc, AV1_SUPERRES_DENOM_BITS);
536
537 av1->upscaled_width = av1->frame_width;
538 }
539
av1_frame_size(vlVaContext * context,struct vl_vlc * vlc)540 static void av1_frame_size(vlVaContext *context, struct vl_vlc *vlc)
541 {
542 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
543
544 if (av1->frame_size_override_flag) {
545 av1->frame_width = av1_f(vlc, av1->seq.frame_width_bits_minus1 + 1) + 1;
546 av1->frame_height = av1_f(vlc, av1->seq.frame_height_bits_minus1 + 1) + 1;
547 } else {
548 av1->frame_width = av1->seq.pic_width_in_luma_samples;
549 av1->frame_height = av1->seq.pic_height_in_luma_samples;
550 }
551
552 unsigned MiCols = 2 * (((av1->frame_width - 1) + 8) >> 3);
553 unsigned MiRows = 2 * (((av1->frame_height - 1) + 8) >> 3);
554 context->desc.av1enc.frame_width_sb = (av1->seq.seq_bits.use_128x128_superblock) ?
555 ((MiCols + 31) >> 5) : ((MiCols + 15) >> 4);
556 context->desc.av1enc.frame_height_sb = (av1->seq.seq_bits.use_128x128_superblock) ?
557 ((MiRows + 31) >> 5) : ((MiRows + 15) >> 4);
558
559 av1_superres_params(context, vlc);
560 }
561
av1_render_size(vlVaContext * context,struct vl_vlc * vlc)562 static void av1_render_size(vlVaContext *context, struct vl_vlc *vlc)
563 {
564 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
565
566 av1->enable_render_size = av1_f(vlc, 1);
567 if (av1->enable_render_size) {
568 av1->render_width = av1_f(vlc, 16);
569 av1->render_height = av1_f(vlc, 16);
570 }
571 }
572
av1_frame_size_with_refs(vlVaContext * context,struct vl_vlc * vlc)573 static void av1_frame_size_with_refs(vlVaContext *context, struct vl_vlc *vlc)
574 {
575 uint8_t found_ref = 0;
576
577 for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
578 found_ref = av1_f(vlc, 1);
579 if (found_ref)
580 break;
581 }
582
583 if (found_ref == 0) {
584 av1_frame_size(context, vlc);
585 av1_render_size(context, vlc);
586 } else
587 av1_superres_params(context, vlc);
588 }
589
av1_read_interpolation_filter(vlVaContext * context,struct vl_vlc * vlc)590 static void av1_read_interpolation_filter(vlVaContext *context, struct vl_vlc *vlc)
591 {
592 uint8_t is_filter_switchable = av1_f(vlc, 1);
593
594 if (!is_filter_switchable)
595 av1_f(vlc, 2);
596 }
597
av1_frame_header(vlVaContext * context,struct vl_vlc * vlc)598 static void av1_frame_header(vlVaContext *context, struct vl_vlc *vlc)
599 {
600 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
601 uint32_t frame_type;
602 uint32_t id_len, all_frames, show_frame;
603
604 bool frame_is_intra = false;
605
606 if (av1->seq.seq_bits.frame_id_number_present_flag)
607 id_len = av1->seq.delta_frame_id_length + av1->seq.additional_frame_id_length;
608
609 all_frames = 255;
610 av1->show_existing_frame = av1_f(vlc, 1);
611 /* use the last reference frame to show */
612 if (av1->show_existing_frame)
613 return;
614
615 frame_type = av1_f(vlc, 2);
616 frame_is_intra = (frame_type == FRAME_TYPE_KEY_FRAME ||
617 frame_type == FRAME_TYPE_INTRA_ONLY);
618 show_frame = av1_f(vlc, 1);
619 if (show_frame && av1->seq.seq_bits.decoder_model_info_present_flag
620 && !(av1->seq.seq_bits.equal_picture_interval)) {
621 struct pipe_av1_enc_decoder_model_info *info = &av1->seq.decoder_model_info;
622 av1_f(vlc, info->frame_presentation_time_length_minus1 + 1);
623 }
624
625 if (!show_frame)
626 av1_f(vlc, 1); /* showable_frame */
627
628 if (frame_type == FRAME_TYPE_SWITCH ||
629 (frame_type == FRAME_TYPE_KEY_FRAME && show_frame))
630 av1->error_resilient_mode = 1;
631 else
632 av1->error_resilient_mode = av1_f(vlc, 1);
633
634 av1->disable_cdf_update = av1_f(vlc, 1);
635 if (av1->seq.seq_bits.force_screen_content_tools == AV1_SELECT_SCREEN_CONTENT_TOOLS)
636 av1->allow_screen_content_tools = av1_f(vlc, 1);
637 else
638 av1->allow_screen_content_tools = !!(av1->seq.seq_bits.force_screen_content_tools);
639
640 av1->force_integer_mv = 0;
641 if (av1->allow_screen_content_tools) {
642 if (av1->seq.seq_bits.force_integer_mv == AV1_SELECT_INTEGER_MV)
643 av1->force_integer_mv = av1_f(vlc, 1);
644 else
645 av1->force_integer_mv = !!(av1->seq.seq_bits.force_integer_mv);
646 }
647
648 if (frame_is_intra)
649 av1->force_integer_mv = 1;
650
651 if (av1->seq.seq_bits.frame_id_number_present_flag)
652 av1_f(vlc, id_len);
653
654 if (frame_type == FRAME_TYPE_SWITCH)
655 av1->frame_size_override_flag = 1;
656 else
657 av1->frame_size_override_flag = av1_f(vlc, 1);
658
659 if (av1->seq.seq_bits.enable_order_hint)
660 av1->order_hint = av1_f(vlc, av1->seq.order_hint_bits);
661
662 if (!(frame_is_intra || av1->error_resilient_mode))
663 av1->primary_ref_frame = av1_f(vlc, 3);
664
665 if (av1->seq.seq_bits.decoder_model_info_present_flag) {
666 unsigned buffer_removal_time_present_flag = av1_f(vlc, 1);
667 if (buffer_removal_time_present_flag) {
668 for (int opNum = 0; opNum <= av1->seq.num_temporal_layers - 1; opNum++) {
669 if (av1->seq.decoder_model_present_for_this_op[opNum]) {
670 uint16_t op_pt_idc = av1->seq.operating_point_idc[opNum];
671 uint16_t temporal_layer = (op_pt_idc >> av1->temporal_id) & 1;
672 uint16_t spatial_layer = (op_pt_idc >> (av1->spatial_id + 8)) & 1;
673 if (op_pt_idc == 0 || (temporal_layer && spatial_layer))
674 av1_f(vlc, av1->seq.decoder_model_info.buffer_removal_time_length_minus1 + 1);
675 }
676 }
677 }
678 }
679
680 if (frame_type == FRAME_TYPE_SWITCH ||
681 (frame_type == FRAME_TYPE_KEY_FRAME && show_frame))
682 av1->refresh_frame_flags = all_frames;
683 else
684 av1->refresh_frame_flags = av1_f(vlc, 8);
685
686 if ( !frame_is_intra || av1->refresh_frame_flags != all_frames) {
687 if (av1->error_resilient_mode && av1->seq.seq_bits.enable_order_hint)
688 for (int i = 0; i < AV1_MAXNUM_REF_FRAMES; i++)
689 av1_f(vlc, av1->seq.order_hint_bits);
690 }
691
692 if ( frame_is_intra) {
693 av1_frame_size(context, vlc);
694 av1_render_size(context, vlc);
695 if (av1->allow_screen_content_tools && av1->upscaled_width == av1->frame_width)
696 av1->allow_intrabc = av1_f(vlc, 1);
697 } else {
698 unsigned frame_refs_short_signaling = 0;
699 if (av1->seq.seq_bits.enable_order_hint) {
700 frame_refs_short_signaling = av1_f(vlc, 1);
701 if (frame_refs_short_signaling) {
702 av1_f(vlc, 3);
703 av1_f(vlc, 3);
704 }
705 }
706
707 for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
708 if (!frame_refs_short_signaling)
709 av1_f(vlc, 3);
710 if (av1->seq.seq_bits.frame_id_number_present_flag)
711 av1_f(vlc, av1->seq.delta_frame_id_length);
712 }
713
714 if (av1->frame_size_override_flag && av1->error_resilient_mode)
715 av1_frame_size_with_refs(context, vlc);
716 else {
717 av1_frame_size(context, vlc);
718 av1_render_size(context, vlc);
719 }
720
721 if (av1->force_integer_mv)
722 av1->allow_high_precision_mv = 0;
723 else
724 av1->allow_high_precision_mv = av1_f(vlc, 1);
725
726 av1_read_interpolation_filter(context, vlc);
727 av1_f(vlc, 1);
728 if (av1->error_resilient_mode || !av1->seq.seq_bits.enable_ref_frame_mvs)
729 av1->use_ref_frame_mvs = 0;
730 else
731 av1->use_ref_frame_mvs = av1_f(vlc, 1);
732
733 if (av1->disable_cdf_update)
734 av1->disable_frame_end_update_cdf = 1;
735 else
736 av1->disable_frame_end_update_cdf = av1_f(vlc, 1);
737 }
738 }
739
740 VAStatus
vlVaHandleVAEncPackedHeaderDataBufferTypeAV1(vlVaContext * context,vlVaBuffer * buf)741 vlVaHandleVAEncPackedHeaderDataBufferTypeAV1(vlVaContext *context, vlVaBuffer *buf)
742 {
743 struct vl_vlc vlc = {0};
744 vl_vlc_init(&vlc, 1, (const void * const*)&buf->data, &buf->size);
745
746 while (vl_vlc_bits_left(&vlc) > 0) {
747 unsigned obu_type = 0;
748 /* search sequece header in the first 8 bytes */
749 for (int i = 0; i < 8 && vl_vlc_bits_left(&vlc) >= 8; ++i) {
750 /* then start decoding , first 5 bits has to be 0000 1xxx for sequence header */
751 obu_type = vl_vlc_peekbits(&vlc, 5);
752 if (obu_type == OBU_TYPE_SEQUENCE_HEADER
753 || obu_type == OBU_TYPE_FRAME_HEADER
754 || obu_type == OBU_TYPE_FRAME)
755 break;
756 vl_vlc_eatbits(&vlc, 8);
757 vl_vlc_fillbits(&vlc);
758 }
759
760 av1_f(&vlc, 5); /* eat known bits */
761 uint32_t extension_flag = av1_f(&vlc, 1);
762 uint32_t has_size = av1_f(&vlc, 1);
763 av1_f(&vlc, 1);
764 if (extension_flag) {
765 context->desc.av1enc.temporal_id = av1_f(&vlc, 3);
766 context->desc.av1enc.spatial_id = av1_f(&vlc, 2);
767 av1_f(&vlc, 3);
768 }
769
770 if (has_size)
771 av1_uleb128(&vlc);
772
773 if (obu_type == OBU_TYPE_SEQUENCE_HEADER)
774 av1_sequence_header(context, &vlc);
775 else if (obu_type == OBU_TYPE_FRAME_HEADER || obu_type == OBU_TYPE_FRAME)
776 av1_frame_header(context, &vlc);
777 else
778 assert(0);
779
780 break;
781 }
782
783 return VA_STATUS_SUCCESS;
784 }
785
786 VAStatus
vlVaHandleVAEncMiscParameterTypeFrameRateAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)787 vlVaHandleVAEncMiscParameterTypeFrameRateAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
788 {
789 VAEncMiscParameterFrameRate *fr = (VAEncMiscParameterFrameRate *)misc->data;
790 for (int i = 0; i < ARRAY_SIZE(context->desc.av1enc.rc); i++) {
791 if (fr->framerate & 0xffff0000) {
792 context->desc.av1enc.rc[i].frame_rate_num = fr->framerate & 0xffff;
793 context->desc.av1enc.rc[i].frame_rate_den = fr->framerate >> 16 & 0xffff;
794 } else {
795 context->desc.av1enc.rc[i].frame_rate_num = fr->framerate;
796 context->desc.av1enc.rc[i].frame_rate_den = 1;
797 }
798 }
799
800 return VA_STATUS_SUCCESS;
801 }
802
getEncParamPresetAV1(vlVaContext * context)803 void getEncParamPresetAV1(vlVaContext *context)
804 {
805 for (int i = 0; i < ARRAY_SIZE(context->desc.av1enc.rc); i++) {
806 struct pipe_av1_enc_rate_control *rc = &context->desc.av1enc.rc[i];
807
808 rc->vbv_buffer_size = 20000000;
809 rc->vbv_buf_lv = 48;
810 rc->fill_data_enable = 1;
811 rc->enforce_hrd = 1;
812 rc->max_qp = 255;
813 rc->min_qp = 1;
814
815 if (rc->frame_rate_num == 0 ||
816 rc->frame_rate_den == 0) {
817 rc->frame_rate_num = 30;
818 rc->frame_rate_den = 1;
819 }
820
821 if (rc->target_bitrate == 0)
822 rc->target_bitrate = 20 * 1000000;
823
824 if (rc->peak_bitrate == 0)
825 rc->peak_bitrate = rc->target_bitrate * 3 / 2;
826
827 rc->target_bits_picture = rc->target_bitrate * rc->frame_rate_den /
828 rc->frame_rate_num;
829
830 rc->peak_bits_picture_integer = rc->peak_bitrate * rc->frame_rate_den /
831 rc->frame_rate_num;
832
833 rc->peak_bits_picture_fraction = 0;
834 }
835 }
836
vlVaHandleVAEncSliceParameterBufferTypeAV1(vlVaDriver * drv,vlVaContext * context,vlVaBuffer * buf)837 VAStatus vlVaHandleVAEncSliceParameterBufferTypeAV1(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
838 {
839 VAEncTileGroupBufferAV1 *tile_buf = (VAEncTileGroupBufferAV1*) buf->data;
840
841 if (context->desc.av1enc.num_tile_groups < ARRAY_SIZE(context->desc.av1enc.tile_groups)) {
842 context->desc.av1enc.tile_groups[context->desc.av1enc.num_tile_groups].tile_group_start = tile_buf->tg_start;
843 context->desc.av1enc.tile_groups[context->desc.av1enc.num_tile_groups].tile_group_end = tile_buf->tg_end;
844 context->desc.av1enc.num_tile_groups++;
845 } else {
846 return VA_STATUS_ERROR_NOT_ENOUGH_BUFFER;
847 }
848
849 return VA_STATUS_SUCCESS;
850 }
851 #endif /* VA_CHECK_VERSION(1, 16, 0) */
852