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_MAXNUM_OPERATING_POINT (32)
38 #define AV1_SUPERRES_DENOM_BITS (8)
39 #define AV1_MAXNUM_REF_FRAMES (8)
40 #define AV1_REFS_PER_FRAME (7)
41 #define FRAME_TYPE_KEY_FRAME (0)
42 #define FRAME_TYPE_INTER_FRAME (1)
43 #define FRAME_TYPE_INTRA_ONLY (2)
44 #define FRAME_TYPE_SWITCH (3)
45 #define OBU_TYPE_SEQUENCE_HEADER (1)
46 #define OBU_TYPE_FRAME_HEADER (3)
47 #define OBU_TYPE_META (5)
48 #define OBU_TYPE_FRAME (6)
49 #define METADATA_TYPE_HDR_CLL (1)
50 #define METADATA_TYPE_HDR_MDCV (2)
51 #define METADATA_TYPE_ITU_T35 (4)
52 #define METADATA_TYPE_TIMECODE (5)
53 #define AV1_MIN_QP_DEFAULT (1)
54 #define AV1_MAX_QP_DEFAULT (255)
55
av1_f(struct vl_vlc * vlc,unsigned n)56 static unsigned av1_f(struct vl_vlc *vlc, unsigned n)
57 {
58 unsigned valid = vl_vlc_valid_bits(vlc);
59
60 if (n == 0)
61 return 0;
62
63 if (valid < 32)
64 vl_vlc_fillbits(vlc);
65
66 return vl_vlc_get_uimsbf(vlc, n);
67 }
68
av1_uvlc(struct vl_vlc * vlc)69 static unsigned av1_uvlc(struct vl_vlc *vlc)
70 {
71 unsigned value;
72 unsigned leadingZeros = 0;
73
74 while (1) {
75 bool done = av1_f(vlc, 1);
76 if (done)
77 break;
78 leadingZeros++;
79 }
80
81 if (leadingZeros >= 32)
82 return 0xffffffff;
83
84 value = av1_f(vlc, leadingZeros);
85
86 return value + (1 << leadingZeros) - 1;
87 }
88
av1_uleb128(struct vl_vlc * vlc)89 static unsigned av1_uleb128(struct vl_vlc *vlc)
90 {
91 uint64_t value = 0;
92 unsigned leb128Bytes = 0;
93 unsigned i;
94
95 for (i = 0; i < 8; ++i) {
96 leb128Bytes = av1_f(vlc, 8);
97 value |= ((uint64_t)(leb128Bytes & 0x7f) << (i * 7));
98 if (!(leb128Bytes & 0x80))
99 break;
100 }
101
102 assert(value <= UINT32_MAX);
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 }
123
124 static uint8_t
vlVaDpbIndex(vlVaContext * context,VASurfaceID id)125 vlVaDpbIndex(vlVaContext *context, VASurfaceID id)
126 {
127 for (uint8_t i = 0; i < context->desc.av1enc.dpb_size; i++) {
128 if (context->desc.av1enc.dpb[i].id == id)
129 return i;
130 }
131 return PIPE_H2645_LIST_REF_INVALID_ENTRY;
132 }
133
vlVaHandleVAEncPictureParameterBufferTypeAV1(vlVaDriver * drv,vlVaContext * context,vlVaBuffer * buf)134 VAStatus vlVaHandleVAEncPictureParameterBufferTypeAV1(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
135 {
136 VAEncPictureParameterBufferAV1 *av1 = buf->data;
137 vlVaBuffer *coded_buf;
138 vlVaSurface *surf;
139 int i, j;
140
141 context->desc.av1enc.disable_frame_end_update_cdf = av1->picture_flags.bits.disable_frame_end_update_cdf;
142 context->desc.av1enc.error_resilient_mode = av1->picture_flags.bits.error_resilient_mode;
143 context->desc.av1enc.disable_cdf_update = av1->picture_flags.bits.disable_cdf_update;
144 context->desc.av1enc.enable_frame_obu = av1->picture_flags.bits.enable_frame_obu;
145 context->desc.av1enc.allow_high_precision_mv = av1->picture_flags.bits.allow_high_precision_mv;
146 context->desc.av1enc.palette_mode_enable = av1->picture_flags.bits.palette_mode_enable;
147 context->desc.av1enc.long_term_reference = av1->picture_flags.bits.long_term_reference;
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 /* Evict unused surfaces */
216 for (i = 0; i < context->desc.av1enc.dpb_size; i++) {
217 struct pipe_av1_enc_dpb_entry *dpb = &context->desc.av1enc.dpb[i];
218 if (!dpb->id || dpb->id == av1->reconstructed_frame)
219 continue;
220 for (j = 0; j < ARRAY_SIZE(av1->reference_frames); j++) {
221 if (av1->reference_frames[j] == dpb->id)
222 break;
223 }
224 if (j == ARRAY_SIZE(av1->reference_frames)) {
225 surf = handle_table_get(drv->htab, dpb->id);
226 assert(surf);
227 surf->is_dpb = false;
228 surf->buffer = NULL;
229 /* Keep the buffer for reuse later */
230 dpb->id = 0;
231 }
232 }
233
234 surf = handle_table_get(drv->htab, av1->reconstructed_frame);
235 if (!surf)
236 return VA_STATUS_ERROR_INVALID_PARAMETER;
237
238 for (i = 0; i < ARRAY_SIZE(context->desc.av1enc.dpb); i++) {
239 if (context->desc.av1enc.dpb[i].id == av1->reconstructed_frame) {
240 assert(surf->is_dpb);
241 break;
242 }
243 if (!surf->is_dpb && !context->desc.av1enc.dpb[i].id) {
244 surf->is_dpb = true;
245 if (surf->buffer) {
246 surf->buffer->destroy(surf->buffer);
247 surf->buffer = NULL;
248 }
249 if (context->decoder->create_dpb_buffer) {
250 struct pipe_video_buffer *buffer = context->desc.av1enc.dpb[i].buffer;
251 if (!buffer) {
252 /* Find unused buffer */
253 for (j = 0; j < context->desc.av1enc.dpb_size; j++) {
254 struct pipe_av1_enc_dpb_entry *dpb = &context->desc.av1enc.dpb[j];
255 if (!dpb->id && dpb->buffer) {
256 buffer = dpb->buffer;
257 dpb->buffer = NULL;
258 break;
259 }
260 }
261 }
262 if (!buffer)
263 buffer = context->decoder->create_dpb_buffer(context->decoder, &context->desc.base, &surf->templat);
264 surf->buffer = buffer;
265 }
266 vlVaSetSurfaceContext(drv, surf, context);
267 if (i == context->desc.av1enc.dpb_size)
268 context->desc.av1enc.dpb_size++;
269 break;
270 }
271 }
272 if (i == ARRAY_SIZE(context->desc.av1enc.dpb))
273 return VA_STATUS_ERROR_INVALID_PARAMETER;
274 context->desc.av1enc.dpb_curr_pic = i;
275 context->desc.av1enc.dpb[i].id = av1->reconstructed_frame;
276 context->desc.av1enc.dpb[i].order_hint = av1->order_hint;
277 context->desc.av1enc.dpb[i].buffer = surf->buffer;
278
279 for (i = 0; i < ARRAY_SIZE(av1->ref_frame_idx); i++) {
280 if (av1->ref_frame_idx[i] > 7)
281 context->desc.av1enc.dpb_ref_frame_idx[i] = PIPE_H2645_LIST_REF_INVALID_ENTRY;
282 else
283 context->desc.av1enc.dpb_ref_frame_idx[i] =
284 vlVaDpbIndex(context, av1->reference_frames[av1->ref_frame_idx[i]]);
285 }
286
287 for (i = 0; i < PIPE_AV1_REFS_PER_FRAME; i++) {
288 uint8_t l0 = (av1->ref_frame_ctrl_l0.value >> (3 * i)) & 0x7;
289 uint8_t l1 = (av1->ref_frame_ctrl_l1.value >> (3 * i)) & 0x7;
290 context->desc.av1enc.ref_list0[i] = l0 ? l0 - 1 : PIPE_H2645_LIST_REF_INVALID_ENTRY;
291 context->desc.av1enc.ref_list1[i] = l1 ? l1 - 1 : PIPE_H2645_LIST_REF_INVALID_ENTRY;
292 if ((l0 && context->desc.av1enc.dpb_ref_frame_idx[l0 - 1] == PIPE_H2645_LIST_REF_INVALID_ENTRY) ||
293 (l1 && context->desc.av1enc.dpb_ref_frame_idx[l1 - 1] == PIPE_H2645_LIST_REF_INVALID_ENTRY))
294 return VA_STATUS_ERROR_INVALID_PARAMETER;
295 }
296
297 coded_buf = handle_table_get(drv->htab, av1->coded_buf);
298 if (!coded_buf)
299 return VA_STATUS_ERROR_INVALID_BUFFER;
300
301 if (!coded_buf->derived_surface.resource)
302 coded_buf->derived_surface.resource = pipe_buffer_create(drv->pipe->screen, PIPE_BIND_VERTEX_BUFFER,
303 PIPE_USAGE_STAGING, coded_buf->size);
304 context->coded_buf = coded_buf;
305
306 /* these frame types will need to be seen as force type */
307 switch(av1->picture_flags.bits.frame_type)
308 {
309 case 0:
310 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_KEY;
311 break;
312 case 1:
313 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_INTER;
314 break;
315 case 2:
316 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_INTRA_ONLY;
317 break;
318 case 3:
319 context->desc.av1enc.frame_type = PIPE_AV1_ENC_FRAME_TYPE_SWITCH;
320 break;
321 };
322
323 for (i = 0; i < ARRAY_SIZE(context->desc.av1enc.rc); i++) {
324 unsigned qindex = av1->base_qindex ? av1->base_qindex : 60;
325 if (context->desc.av1enc.frame_type == PIPE_AV1_ENC_FRAME_TYPE_KEY ||
326 context->desc.av1enc.frame_type == PIPE_AV1_ENC_FRAME_TYPE_INTRA_ONLY)
327 context->desc.av1enc.rc[i].qp = qindex;
328 else
329 context->desc.av1enc.rc[i].qp_inter = qindex;
330 /* Distinguishes from the default params set for these values and app specific params passed down */
331 context->desc.av1enc.rc[i].app_requested_initial_qp = (av1->base_qindex != 0);
332 context->desc.av1enc.rc[i].min_qp = av1->min_base_qindex ? av1->min_base_qindex : 1;
333 context->desc.av1enc.rc[i].max_qp = av1->max_base_qindex ? av1->max_base_qindex : 255;
334 /* Distinguishes from the default params set for these values and app specific params passed down */
335 context->desc.av1enc.rc[i].app_requested_qp_range =
336 ((context->desc.av1enc.rc[i].max_qp != AV1_MAX_QP_DEFAULT) || (context->desc.av1enc.rc[i].min_qp != AV1_MIN_QP_DEFAULT));
337 }
338
339 if (context->desc.av1enc.frame_type == FRAME_TYPE_KEY_FRAME)
340 context->desc.av1enc.last_key_frame_num = context->desc.av1enc.frame_num;
341
342 /* Initialize slice descriptors for this picture */
343 context->desc.av1enc.num_tile_groups = 0;
344 memset(&context->desc.av1enc.tile_groups, 0, sizeof(context->desc.av1enc.tile_groups));
345
346 return VA_STATUS_SUCCESS;
347 }
348
vlVaHandleVAEncMiscParameterTypeRateControlAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)349 VAStatus vlVaHandleVAEncMiscParameterTypeRateControlAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
350 {
351 unsigned temporal_id;
352 VAEncMiscParameterRateControl *rc = (VAEncMiscParameterRateControl *)misc->data;
353 struct pipe_av1_enc_rate_control *pipe_rc = NULL;
354
355 temporal_id = context->desc.av1enc.rc[0].rate_ctrl_method !=
356 PIPE_H2645_ENC_RATE_CONTROL_METHOD_DISABLE ?
357 rc->rc_flags.bits.temporal_id :
358 0;
359
360 if (context->desc.av1enc.seq.num_temporal_layers > 0 &&
361 temporal_id >= context->desc.av1enc.seq.num_temporal_layers)
362 return VA_STATUS_ERROR_INVALID_PARAMETER;
363
364 pipe_rc = &context->desc.av1enc.rc[temporal_id];
365
366 if (pipe_rc->rate_ctrl_method == PIPE_H2645_ENC_RATE_CONTROL_METHOD_CONSTANT)
367 pipe_rc->target_bitrate = rc->bits_per_second;
368 else
369 pipe_rc->target_bitrate = rc->bits_per_second * (rc->target_percentage / 100.0);
370 pipe_rc->peak_bitrate = rc->bits_per_second;
371 if (pipe_rc->target_bitrate < 2000000)
372 pipe_rc->vbv_buffer_size = MIN2((pipe_rc->target_bitrate * 2.75), 2000000);
373 else
374 pipe_rc->vbv_buffer_size = pipe_rc->target_bitrate;
375
376 pipe_rc->fill_data_enable = !(rc->rc_flags.bits.disable_bit_stuffing);
377 pipe_rc->skip_frame_enable = 0;/* !(rc->rc_flags.bits.disable_frame_skip); */
378 pipe_rc->max_qp = rc->max_qp;
379 pipe_rc->min_qp = rc->min_qp;
380 /* Distinguishes from the default params set for these values in other
381 functions and app specific params passed down */
382 pipe_rc->app_requested_qp_range = ((rc->max_qp > 0) || (rc->min_qp > 0));
383
384 if (pipe_rc->rate_ctrl_method == PIPE_H2645_ENC_RATE_CONTROL_METHOD_QUALITY_VARIABLE)
385 pipe_rc->vbr_quality_factor = rc->quality_factor;
386
387 return VA_STATUS_SUCCESS;
388 }
389
390 VAStatus
vlVaHandleVAEncMiscParameterTypeQualityLevelAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)391 vlVaHandleVAEncMiscParameterTypeQualityLevelAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
392 {
393 VAEncMiscParameterBufferQualityLevel *ql = (VAEncMiscParameterBufferQualityLevel *)misc->data;
394 vlVaHandleVAEncMiscParameterTypeQualityLevel(&context->desc.av1enc.quality_modes,
395 (vlVaQualityBits *)&ql->quality_level);
396
397 return VA_STATUS_SUCCESS;
398 }
399
400 VAStatus
vlVaHandleVAEncMiscParameterTypeMaxFrameSizeAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)401 vlVaHandleVAEncMiscParameterTypeMaxFrameSizeAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
402 {
403 VAEncMiscParameterBufferMaxFrameSize *ms = (VAEncMiscParameterBufferMaxFrameSize *)misc->data;
404 context->desc.av1enc.rc[0].max_au_size = ms->max_frame_size;
405 return VA_STATUS_SUCCESS;
406 }
407
408 VAStatus
vlVaHandleVAEncMiscParameterTypeHRDAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)409 vlVaHandleVAEncMiscParameterTypeHRDAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
410 {
411 VAEncMiscParameterHRD *ms = (VAEncMiscParameterHRD *)misc->data;
412
413 if (ms->buffer_size == 0)
414 return VA_STATUS_ERROR_INVALID_PARAMETER;
415
416 /* Distinguishes from the default params set for these values in other
417 functions and app specific params passed down via HRD buffer */
418 context->desc.av1enc.rc[0].app_requested_hrd_buffer = true;
419 context->desc.av1enc.rc[0].vbv_buffer_size = ms->buffer_size;
420 context->desc.av1enc.rc[0].vbv_buf_lv = (ms->initial_buffer_fullness << 6) / ms->buffer_size;
421 context->desc.av1enc.rc[0].vbv_buf_initial_size = ms->initial_buffer_fullness;
422
423 for (unsigned i = 1; i < context->desc.av1enc.seq.num_temporal_layers; i++) {
424 context->desc.av1enc.rc[i].vbv_buffer_size =
425 (float)ms->buffer_size / context->desc.av1enc.rc[0].peak_bitrate *
426 context->desc.av1enc.rc[i].peak_bitrate;
427 context->desc.av1enc.rc[i].vbv_buf_lv = context->desc.av1enc.rc[0].vbv_buf_lv;
428 context->desc.av1enc.rc[i].vbv_buf_initial_size =
429 (context->desc.av1enc.rc[i].vbv_buffer_size * context->desc.av1enc.rc[i].vbv_buf_lv) >> 6;
430 }
431
432 return VA_STATUS_SUCCESS;
433 }
434
av1_color_config(vlVaContext * context,struct vl_vlc * vlc)435 static void av1_color_config(vlVaContext *context, struct vl_vlc *vlc)
436 {
437 unsigned high_bitdepth = 0;
438 unsigned bit_depth = 8;
439 unsigned mono_chrome = 0;
440 unsigned subsampling_x = 0, subsampling_y = 0;
441
442 struct pipe_av1_enc_seq_param *seq = &context->desc.av1enc.seq;
443
444 high_bitdepth = av1_f(vlc, 1);
445 if (seq->profile == 2 && high_bitdepth) {
446 unsigned twelve_bit = av1_f(vlc, 1);
447 bit_depth = twelve_bit ? 12 : 10;
448 } else if (seq->profile <= 2)
449 bit_depth = high_bitdepth ? 10 : 8;
450
451 context->desc.av1enc.seq.bit_depth_minus8 = bit_depth - 8;
452
453 if (seq->profile == 1)
454 mono_chrome = 0;
455 else
456 mono_chrome = av1_f(vlc, 1);
457
458 seq->seq_bits.color_description_present_flag = av1_f(vlc, 1);
459 if (seq->seq_bits.color_description_present_flag) {
460 seq->color_config.color_primaries = av1_f(vlc, 8);
461 seq->color_config.transfer_characteristics = av1_f(vlc, 8);
462 seq->color_config.matrix_coefficients = av1_f(vlc, 8);
463 } else {
464 seq->color_config.color_primaries = 2;
465 seq->color_config.transfer_characteristics = 2;
466 seq->color_config.matrix_coefficients = 2;
467 }
468
469 if (mono_chrome) {
470 seq->color_config.color_range = av1_f(vlc, 1);
471 subsampling_x = subsampling_y = 1;
472 seq->color_config.chroma_sample_position = 0;
473 return;
474 } else if (seq->color_config.color_primaries == 1 && /* CP_BT_709 */
475 seq->color_config.transfer_characteristics == 13 && /* TC_SRGB */
476 seq->color_config.matrix_coefficients == 0) { /* MC_IDENTITY */
477 seq->color_config.color_range = 1;
478 subsampling_x = subsampling_y = 0;
479 } else {
480 seq->color_config.color_range = av1_f(vlc, 1);
481 if (seq->profile == 0)
482 subsampling_x = subsampling_y = 1;
483 else if (seq->profile == 1)
484 subsampling_x = subsampling_y = 0;
485 else {
486 if (bit_depth == 12) {
487 subsampling_x = av1_f(vlc, 1);
488 if (subsampling_x)
489 subsampling_y = av1_f(vlc, 1);
490 else
491 subsampling_y = 0;
492 }
493 }
494 if (subsampling_x && subsampling_y)
495 seq->color_config.chroma_sample_position = av1_f(vlc, 2);
496 }
497
498 av1_f(vlc, 1);
499 }
500
av1_sequence_header(vlVaContext * context,struct vl_vlc * vlc)501 static void av1_sequence_header(vlVaContext *context, struct vl_vlc *vlc)
502 {
503 struct pipe_av1_enc_seq_param *seq = &context->desc.av1enc.seq;
504
505 seq->profile = av1_f(vlc, 3);
506 seq->seq_bits.still_picture = av1_f(vlc, 1);
507 seq->seq_bits.reduced_still_picture_header = av1_f(vlc, 1);
508 if (seq->seq_bits.reduced_still_picture_header) {
509 seq->seq_level_idx[0] = av1_f(vlc, 5);
510 } else {
511 seq->seq_bits.timing_info_present_flag = av1_f(vlc, 1);
512 if (seq->seq_bits.timing_info_present_flag) {
513 seq->num_units_in_display_tick = av1_f(vlc, 32);
514 seq->time_scale = av1_f(vlc, 32);
515 seq->seq_bits.equal_picture_interval = av1_f(vlc, 1);
516 if (seq->seq_bits.equal_picture_interval)
517 seq->num_tick_per_picture_minus1 = av1_uvlc(vlc);
518 seq->seq_bits.decoder_model_info_present_flag = av1_f(vlc, 1);
519 if (seq->seq_bits.decoder_model_info_present_flag) {
520 struct pipe_av1_enc_decoder_model_info *info = &seq->decoder_model_info;
521 info->buffer_delay_length_minus1 = av1_f(vlc, 5);
522 info->num_units_in_decoding_tick = av1_f(vlc, 32);
523 info->buffer_removal_time_length_minus1 = av1_f(vlc, 5);
524 info->frame_presentation_time_length_minus1 = av1_f(vlc, 5);
525 }
526 }
527 seq->seq_bits.initial_display_delay_present_flag = av1_f(vlc, 1);
528 seq->num_temporal_layers = av1_f(vlc, 5) + 1;
529 for (unsigned i = 0; i < seq->num_temporal_layers; i++) {
530 seq->operating_point_idc[i] = av1_f(vlc, 12);
531 seq->seq_level_idx[i] = av1_f(vlc, 5);
532 if (seq->seq_level_idx[i] > 7)
533 seq->seq_tier[i] = av1_f(vlc, 1);
534 if (seq->seq_bits.decoder_model_info_present_flag) {
535 seq->decoder_model_present_for_this_op[i] = av1_f(vlc, 1);
536 if (seq->decoder_model_present_for_this_op[i]) {
537 seq->decoder_buffer_delay[i] = av1_f(vlc, seq->decoder_model_info.buffer_delay_length_minus1 + 1);
538 seq->encoder_buffer_delay[i] = av1_f(vlc, seq->decoder_model_info.buffer_delay_length_minus1 + 1);
539 seq->low_delay_mode_flag[i] = av1_f(vlc, 1);
540 } else
541 seq->decoder_model_present_for_this_op[i] = 0;
542 }
543 if (seq->seq_bits.initial_display_delay_present_flag) {
544 seq->initial_display_delay_present_for_this_op[i] = av1_f(vlc, 1);
545 if (seq->initial_display_delay_present_for_this_op[i])
546 seq->initial_display_delay_minus_1[i] = av1_f(vlc, 4);
547 }
548 }
549 }
550 seq->frame_width_bits_minus1 = av1_f(vlc, 4);
551 seq->frame_height_bits_minus1 = av1_f(vlc, 4);
552 seq->pic_width_in_luma_samples = av1_f(vlc, seq->frame_width_bits_minus1 + 1) + 1;
553 seq->pic_height_in_luma_samples = av1_f(vlc, seq->frame_height_bits_minus1 + 1) + 1;
554 if (!seq->seq_bits.reduced_still_picture_header)
555 seq->seq_bits.frame_id_number_present_flag = av1_f(vlc, 1);
556 if (seq->seq_bits.frame_id_number_present_flag) {
557 seq->delta_frame_id_length = av1_f(vlc, 4) + 2;
558 seq->additional_frame_id_length = av1_f(vlc, 3) + 1;
559 }
560 seq->seq_bits.use_128x128_superblock = av1_f(vlc, 1);
561 seq->seq_bits.enable_filter_intra = av1_f(vlc, 1);
562 seq->seq_bits.enable_intra_edge_filter = av1_f(vlc, 1);
563 if (!seq->seq_bits.reduced_still_picture_header) {
564 seq->seq_bits.enable_interintra_compound = av1_f(vlc, 1);
565 seq->seq_bits.enable_masked_compound = av1_f(vlc, 1);
566 seq->seq_bits.enable_warped_motion = av1_f(vlc, 1);
567 seq->seq_bits.enable_dual_filter = av1_f(vlc, 1);
568 seq->seq_bits.enable_order_hint = av1_f(vlc, 1);
569 if (seq->seq_bits.enable_order_hint) {
570 seq->seq_bits.enable_jnt_comp = av1_f(vlc, 1);
571 seq->seq_bits.enable_ref_frame_mvs = av1_f(vlc, 1);
572 } else
573 seq->seq_bits.enable_ref_frame_mvs = 0;
574
575 seq->seq_bits.disable_screen_content_tools = av1_f(vlc, 1);
576 if (seq->seq_bits.disable_screen_content_tools)
577 seq->seq_bits.force_screen_content_tools = AV1_SELECT_SCREEN_CONTENT_TOOLS;
578 else
579 seq->seq_bits.force_screen_content_tools = av1_f(vlc, 1);
580
581 seq->seq_bits.force_integer_mv = AV1_SELECT_INTEGER_MV;
582 if (seq->seq_bits.force_screen_content_tools) {
583 seq->seq_bits.choose_integer_mv = av1_f(vlc, 1);
584 if (!seq->seq_bits.choose_integer_mv)
585 seq->seq_bits.force_integer_mv = av1_f(vlc, 1);
586 }
587 if (seq->seq_bits.enable_order_hint)
588 seq->order_hint_bits = av1_f(vlc, 3) + 1;
589 else
590 seq->order_hint_bits = 0;
591 }
592 seq->seq_bits.enable_superres = av1_f(vlc, 1);
593 seq->seq_bits.enable_cdef = av1_f(vlc, 1);
594 seq->seq_bits.enable_restoration = av1_f(vlc, 1);
595 av1_color_config(context, vlc);
596 }
597
av1_superres_params(vlVaContext * context,struct vl_vlc * vlc)598 static void av1_superres_params(vlVaContext *context, struct vl_vlc *vlc)
599 {
600 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
601 uint8_t use_superres;
602
603 if (av1->seq.seq_bits.enable_superres)
604 use_superres = av1_f(vlc, 1);
605 else
606 use_superres = 0;
607
608 if (use_superres)
609 av1_f(vlc, AV1_SUPERRES_DENOM_BITS);
610
611 av1->upscaled_width = av1->frame_width;
612 }
613
av1_frame_size(vlVaContext * context,struct vl_vlc * vlc)614 static void av1_frame_size(vlVaContext *context, struct vl_vlc *vlc)
615 {
616 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
617
618 if (av1->frame_size_override_flag) {
619 av1->frame_width = av1_f(vlc, av1->seq.frame_width_bits_minus1 + 1) + 1;
620 av1->frame_height = av1_f(vlc, av1->seq.frame_height_bits_minus1 + 1) + 1;
621 } else {
622 av1->frame_width = av1->seq.pic_width_in_luma_samples;
623 av1->frame_height = av1->seq.pic_height_in_luma_samples;
624 }
625
626 unsigned MiCols = 2 * (((av1->frame_width - 1) + 8) >> 3);
627 unsigned MiRows = 2 * (((av1->frame_height - 1) + 8) >> 3);
628 context->desc.av1enc.frame_width_sb = (av1->seq.seq_bits.use_128x128_superblock) ?
629 ((MiCols + 31) >> 5) : ((MiCols + 15) >> 4);
630 context->desc.av1enc.frame_height_sb = (av1->seq.seq_bits.use_128x128_superblock) ?
631 ((MiRows + 31) >> 5) : ((MiRows + 15) >> 4);
632
633 av1_superres_params(context, vlc);
634 }
635
av1_render_size(vlVaContext * context,struct vl_vlc * vlc)636 static void av1_render_size(vlVaContext *context, struct vl_vlc *vlc)
637 {
638 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
639
640 av1->enable_render_size = av1_f(vlc, 1);
641 if (av1->enable_render_size) {
642 av1->render_width_minus_1 = av1_f(vlc, 16);
643 av1->render_height_minus_1 = av1_f(vlc, 16);
644 }
645 }
646
av1_frame_size_with_refs(vlVaContext * context,struct vl_vlc * vlc)647 static void av1_frame_size_with_refs(vlVaContext *context, struct vl_vlc *vlc)
648 {
649 uint8_t found_ref = 0;
650
651 for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
652 found_ref = av1_f(vlc, 1);
653 if (found_ref)
654 break;
655 }
656
657 if (found_ref == 0) {
658 av1_frame_size(context, vlc);
659 av1_render_size(context, vlc);
660 } else
661 av1_superres_params(context, vlc);
662 }
663
av1_read_interpolation_filter(vlVaContext * context,struct vl_vlc * vlc)664 static void av1_read_interpolation_filter(vlVaContext *context, struct vl_vlc *vlc)
665 {
666 uint8_t is_filter_switchable = av1_f(vlc, 1);
667
668 if (!is_filter_switchable)
669 av1_f(vlc, 2);
670 }
671
av1_frame_header(vlVaContext * context,struct vl_vlc * vlc,uint32_t extension_flag,uint32_t temporal_id,uint32_t spatial_id)672 static bool av1_frame_header(vlVaContext *context, struct vl_vlc *vlc,
673 uint32_t extension_flag, uint32_t temporal_id, uint32_t spatial_id)
674 {
675 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
676 uint32_t frame_type;
677 uint32_t id_len = 0, all_frames = 255;
678 bool frame_is_intra = false;
679
680 if (av1->seq.seq_bits.reduced_still_picture_header) {
681 frame_is_intra = true;
682 frame_type = FRAME_TYPE_KEY_FRAME;
683 av1->show_frame = 1;
684 } else {
685 if (av1->seq.seq_bits.frame_id_number_present_flag)
686 id_len = av1->seq.delta_frame_id_length + av1->seq.additional_frame_id_length;
687
688 if (av1_f(vlc, 1)) /* show_existing_frame */
689 return false;
690
691 av1->obu_extension_flag = extension_flag;
692 av1->temporal_id = temporal_id;
693 av1->spatial_id = spatial_id;
694
695 frame_type = av1_f(vlc, 2);
696 frame_is_intra = (frame_type == FRAME_TYPE_KEY_FRAME ||
697 frame_type == FRAME_TYPE_INTRA_ONLY);
698 av1->show_frame = av1_f(vlc, 1);
699 if (av1->show_frame && av1->seq.seq_bits.decoder_model_info_present_flag
700 && !(av1->seq.seq_bits.equal_picture_interval)) {
701 struct pipe_av1_enc_decoder_model_info *info = &av1->seq.decoder_model_info;
702 av1->frame_presentation_time = av1_f(vlc, info->frame_presentation_time_length_minus1 + 1);
703 }
704
705 if (!av1->show_frame)
706 av1->showable_frame = av1_f(vlc, 1);
707
708 if (frame_type == FRAME_TYPE_SWITCH ||
709 (frame_type == FRAME_TYPE_KEY_FRAME && av1->show_frame))
710 av1->error_resilient_mode = 1;
711 else
712 av1->error_resilient_mode = av1_f(vlc, 1);
713 }
714
715 av1->disable_cdf_update = av1_f(vlc, 1);
716 if (av1->seq.seq_bits.force_screen_content_tools == AV1_SELECT_SCREEN_CONTENT_TOOLS)
717 av1->allow_screen_content_tools = av1_f(vlc, 1);
718 else
719 av1->allow_screen_content_tools = !!(av1->seq.seq_bits.force_screen_content_tools);
720
721 av1->force_integer_mv = 0;
722 if (av1->allow_screen_content_tools) {
723 if (av1->seq.seq_bits.force_integer_mv == AV1_SELECT_INTEGER_MV)
724 av1->force_integer_mv = av1_f(vlc, 1);
725 else
726 av1->force_integer_mv = !!(av1->seq.seq_bits.force_integer_mv);
727 }
728
729 if (frame_is_intra)
730 av1->force_integer_mv = 1;
731
732 if (av1->seq.seq_bits.frame_id_number_present_flag)
733 av1->current_frame_id = av1_f(vlc, id_len);
734
735 if (frame_type == FRAME_TYPE_SWITCH)
736 av1->frame_size_override_flag = 1;
737 else if (!av1->seq.seq_bits.reduced_still_picture_header)
738 av1->frame_size_override_flag = av1_f(vlc, 1);
739
740 if (av1->seq.seq_bits.enable_order_hint)
741 av1->order_hint = av1_f(vlc, av1->seq.order_hint_bits);
742
743 if (!(frame_is_intra || av1->error_resilient_mode))
744 av1->primary_ref_frame = av1_f(vlc, 3);
745
746 if (av1->seq.seq_bits.decoder_model_info_present_flag) {
747 unsigned buffer_removal_time_present_flag = av1_f(vlc, 1);
748 if (buffer_removal_time_present_flag) {
749 for (int opNum = 0; opNum <= av1->seq.num_temporal_layers - 1; opNum++) {
750 if (av1->seq.decoder_model_present_for_this_op[opNum]) {
751 uint16_t op_pt_idc = av1->seq.operating_point_idc[opNum];
752 uint16_t temporal_layer = (op_pt_idc >> av1->temporal_id) & 1;
753 uint16_t spatial_layer = (op_pt_idc >> (av1->spatial_id + 8)) & 1;
754 if (op_pt_idc == 0 || (temporal_layer && spatial_layer))
755 av1_f(vlc, av1->seq.decoder_model_info.buffer_removal_time_length_minus1 + 1);
756 }
757 }
758 }
759 }
760
761 if (frame_type == FRAME_TYPE_SWITCH ||
762 (frame_type == FRAME_TYPE_KEY_FRAME && av1->show_frame))
763 av1->refresh_frame_flags = all_frames;
764 else
765 av1->refresh_frame_flags = av1_f(vlc, 8);
766
767 if ( !frame_is_intra || av1->refresh_frame_flags != all_frames) {
768 if (av1->error_resilient_mode && av1->seq.seq_bits.enable_order_hint)
769 for (int i = 0; i < AV1_MAXNUM_REF_FRAMES; i++)
770 av1->ref_order_hint[i] = av1_f(vlc, av1->seq.order_hint_bits);
771 }
772
773 if ( frame_is_intra) {
774 av1_frame_size(context, vlc);
775 av1_render_size(context, vlc);
776 if (av1->allow_screen_content_tools && av1->upscaled_width == av1->frame_width)
777 av1->allow_intrabc = av1_f(vlc, 1);
778 } else {
779 av1->frame_refs_short_signaling = 0;
780 if (av1->seq.seq_bits.enable_order_hint) {
781 av1->frame_refs_short_signaling = av1_f(vlc, 1);
782 if (av1->frame_refs_short_signaling) {
783 av1->last_frame_idx = av1_f(vlc, 3);
784 av1->gold_frame_idx = av1_f(vlc, 3);
785 }
786 }
787
788 for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {
789 if (!av1->frame_refs_short_signaling)
790 av1->ref_frame_idx[i] = av1_f(vlc, 3);
791 if (av1->seq.seq_bits.frame_id_number_present_flag)
792 av1->delta_frame_id_minus_1[i] = av1_f(vlc, av1->seq.delta_frame_id_length);
793 }
794
795 if (av1->frame_size_override_flag && av1->error_resilient_mode)
796 av1_frame_size_with_refs(context, vlc);
797 else {
798 av1_frame_size(context, vlc);
799 av1_render_size(context, vlc);
800 }
801
802 if (av1->force_integer_mv)
803 av1->allow_high_precision_mv = 0;
804 else
805 av1->allow_high_precision_mv = av1_f(vlc, 1);
806
807 av1_read_interpolation_filter(context, vlc);
808 av1->is_motion_mode_switchable = av1_f(vlc, 1);
809 if (av1->error_resilient_mode || !av1->seq.seq_bits.enable_ref_frame_mvs)
810 av1->use_ref_frame_mvs = 0;
811 else
812 av1->use_ref_frame_mvs = av1_f(vlc, 1);
813 }
814
815 if (av1->seq.seq_bits.reduced_still_picture_header || av1->disable_cdf_update)
816 av1->disable_frame_end_update_cdf = 1;
817 else
818 av1->disable_frame_end_update_cdf = av1_f(vlc, 1);
819
820 /* tile_info()
821 * trying to keep uniform_tile_spacing_flag
822 * if the tile rows and columns are not within the range
823 * of HW capability, it will need to redo the tiling
824 * according to the limixation.
825 */
826
827 av1->uniform_tile_spacing = av1_f(vlc, 1);
828
829 return true;
830 }
831
av1_metatype_hdr_cll(vlVaContext * context,struct vl_vlc * vlc)832 static void av1_metatype_hdr_cll(vlVaContext *context, struct vl_vlc *vlc)
833 {
834 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
835
836 av1->metadata_flags.hdr_cll = 1;
837 av1->metadata_hdr_cll.max_cll = av1_f(vlc, 16);
838 av1->metadata_hdr_cll.max_fall = av1_f(vlc, 16);
839 }
840
av1_metatype_hdr_mdcv(vlVaContext * context,struct vl_vlc * vlc)841 static void av1_metatype_hdr_mdcv(vlVaContext *context, struct vl_vlc *vlc)
842 {
843 struct pipe_av1_enc_picture_desc *av1 = &context->desc.av1enc;
844
845 av1->metadata_flags.hdr_mdcv = 1;
846
847 for (int32_t i = 0; i < 3; i++) {
848 av1->metadata_hdr_mdcv.primary_chromaticity_x[i] = av1_f(vlc, 16);
849 av1->metadata_hdr_mdcv.primary_chromaticity_y[i] = av1_f(vlc, 16);
850 }
851 av1->metadata_hdr_mdcv.white_point_chromaticity_x = av1_f(vlc, 16);
852 av1->metadata_hdr_mdcv.white_point_chromaticity_y = av1_f(vlc, 16);
853 av1->metadata_hdr_mdcv.luminance_max = av1_f(vlc, 32);
854 av1->metadata_hdr_mdcv.luminance_min = av1_f(vlc, 32);
855 }
856
av1_meta_obu(vlVaContext * context,struct vl_vlc * vlc)857 static void av1_meta_obu(vlVaContext *context, struct vl_vlc *vlc)
858 {
859 unsigned meta_type = av1_uleb128(vlc);
860
861 if (meta_type == METADATA_TYPE_HDR_CLL)
862 av1_metatype_hdr_cll(context, vlc);
863 else if (meta_type == METADATA_TYPE_HDR_MDCV)
864 av1_metatype_hdr_mdcv(context, vlc);
865 }
866
867 VAStatus
vlVaHandleVAEncPackedHeaderDataBufferTypeAV1(vlVaContext * context,vlVaBuffer * buf)868 vlVaHandleVAEncPackedHeaderDataBufferTypeAV1(vlVaContext *context, vlVaBuffer *buf)
869 {
870 struct vl_vlc vlc = {0};
871 vl_vlc_init(&vlc, 1, (const void * const*)&buf->data, &buf->size);
872
873 av1_f(&vlc, 1); /* obu_forbidden_bit */
874 uint32_t obu_type = av1_f(&vlc, 4);
875
876 if (obu_type != OBU_TYPE_SEQUENCE_HEADER &&
877 obu_type != OBU_TYPE_FRAME_HEADER &&
878 obu_type != OBU_TYPE_FRAME &&
879 obu_type != OBU_TYPE_META) {
880 vlVaAddRawHeader(&context->desc.av1enc.raw_headers, obu_type,
881 buf->size, buf->data, false, 0);
882 return VA_STATUS_SUCCESS;
883 }
884
885 uint32_t extension_flag = av1_f(&vlc, 1);
886 uint32_t has_size = av1_f(&vlc, 1);
887 av1_f(&vlc, 1); /* obu_reserved_1bit */
888
889 uint32_t temporal_id = 0;
890 uint32_t spatial_id = 0;
891
892 if (extension_flag) {
893 temporal_id = av1_f(&vlc, 3);
894 spatial_id = av1_f(&vlc, 2);
895 av1_f(&vlc, 3); /* extension_header_reserved_3bits */
896 }
897
898 if (has_size)
899 av1_uleb128(&vlc);
900
901 bool is_frame = false;
902
903 if (obu_type == OBU_TYPE_SEQUENCE_HEADER)
904 av1_sequence_header(context, &vlc);
905 else if (obu_type == OBU_TYPE_FRAME_HEADER || obu_type == OBU_TYPE_FRAME)
906 is_frame = av1_frame_header(context, &vlc, extension_flag, temporal_id, spatial_id);
907 else if (obu_type == OBU_TYPE_META)
908 av1_meta_obu(context, &vlc);
909
910 vlVaAddRawHeader(&context->desc.av1enc.raw_headers, obu_type,
911 buf->size, buf->data, is_frame, 0);
912
913 return VA_STATUS_SUCCESS;
914 }
915
916 VAStatus
vlVaHandleVAEncMiscParameterTypeFrameRateAV1(vlVaContext * context,VAEncMiscParameterBuffer * misc)917 vlVaHandleVAEncMiscParameterTypeFrameRateAV1(vlVaContext *context, VAEncMiscParameterBuffer *misc)
918 {
919 unsigned temporal_id;
920 VAEncMiscParameterFrameRate *fr = (VAEncMiscParameterFrameRate *)misc->data;
921
922 temporal_id = context->desc.av1enc.rc[0].rate_ctrl_method !=
923 PIPE_H2645_ENC_RATE_CONTROL_METHOD_DISABLE ?
924 fr->framerate_flags.bits.temporal_id :
925 0;
926
927 if (context->desc.av1enc.seq.num_temporal_layers > 0 &&
928 temporal_id >= context->desc.av1enc.seq.num_temporal_layers)
929 return VA_STATUS_ERROR_INVALID_PARAMETER;
930
931 if (fr->framerate & 0xffff0000) {
932 context->desc.av1enc.rc[temporal_id].frame_rate_num = fr->framerate & 0xffff;
933 context->desc.av1enc.rc[temporal_id].frame_rate_den = fr->framerate >> 16 & 0xffff;
934 } else {
935 context->desc.av1enc.rc[temporal_id].frame_rate_num = fr->framerate;
936 context->desc.av1enc.rc[temporal_id].frame_rate_den = 1;
937 }
938
939 return VA_STATUS_SUCCESS;
940 }
941
vlVaHandleVAEncSliceParameterBufferTypeAV1(vlVaDriver * drv,vlVaContext * context,vlVaBuffer * buf)942 VAStatus vlVaHandleVAEncSliceParameterBufferTypeAV1(vlVaDriver *drv, vlVaContext *context, vlVaBuffer *buf)
943 {
944 VAEncTileGroupBufferAV1 *tile_buf = (VAEncTileGroupBufferAV1*) buf->data;
945
946 if (context->desc.av1enc.num_tile_groups < ARRAY_SIZE(context->desc.av1enc.tile_groups)) {
947 context->desc.av1enc.tile_groups[context->desc.av1enc.num_tile_groups].tile_group_start = tile_buf->tg_start;
948 context->desc.av1enc.tile_groups[context->desc.av1enc.num_tile_groups].tile_group_end = tile_buf->tg_end;
949 context->desc.av1enc.num_tile_groups++;
950 } else {
951 return VA_STATUS_ERROR_NOT_ENOUGH_BUFFER;
952 }
953
954 return VA_STATUS_SUCCESS;
955 }
956 #endif /* VA_CHECK_VERSION(1, 16, 0) */
957