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