1 /**************************************************************************
2 *
3 * Copyright 2017 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 "radeon_vcn_dec.h"
29
30 #include "pipe/p_video_codec.h"
31 #include "radeonsi/si_pipe.h"
32 #include "util/u_memory.h"
33 #include "util/u_video.h"
34 #include "vl/vl_mpeg12_decoder.h"
35 #include "vl/vl_probs_table.h"
36 #include "pspdecryptionparam.h"
37
38 #include <assert.h>
39 #include <stdio.h>
40
41 #include "radeon_vcn_av1_default.h"
42
43 #define FB_BUFFER_OFFSET 0x1000
44 #define FB_BUFFER_SIZE 2048
45 #define IT_SCALING_TABLE_SIZE 992
46 #define VP9_PROBS_TABLE_SIZE (RDECODE_VP9_PROBS_DATA_SIZE + 256)
47
48 #define NUM_MPEG2_REFS 6
49 #define NUM_H264_REFS 17
50 #define NUM_VC1_REFS 5
51 #define NUM_VP9_REFS 8
52 #define NUM_AV1_REFS 8
53 #define NUM_AV1_REFS_PER_FRAME 7
54
55 static unsigned calc_dpb_size(struct radeon_decoder *dec);
56 static unsigned calc_ctx_size_h264_perf(struct radeon_decoder *dec);
57 static unsigned calc_ctx_size_h265_main(struct radeon_decoder *dec);
58 static unsigned calc_ctx_size_h265_main10(struct radeon_decoder *dec,
59 struct pipe_h265_picture_desc *pic);
60
radeon_dec_destroy_associated_data(void *data)61 static void radeon_dec_destroy_associated_data(void *data)
62 {
63 /* NOOP, since we only use an intptr */
64 }
65
get_h264_msg(struct radeon_decoder *dec, struct pipe_video_buffer *target, struct pipe_h264_picture_desc *pic)66 static rvcn_dec_message_avc_t get_h264_msg(struct radeon_decoder *dec,
67 struct pipe_video_buffer *target,
68 struct pipe_h264_picture_desc *pic)
69 {
70 rvcn_dec_message_avc_t result;
71 struct h264_private *private;
72 unsigned i, j, k;
73
74 memset(&result, 0, sizeof(result));
75 switch (pic->base.profile) {
76 case PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE:
77 case PIPE_VIDEO_PROFILE_MPEG4_AVC_CONSTRAINED_BASELINE:
78 result.profile = RDECODE_H264_PROFILE_BASELINE;
79 break;
80
81 case PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN:
82 result.profile = RDECODE_H264_PROFILE_MAIN;
83 break;
84
85 case PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH:
86 result.profile = RDECODE_H264_PROFILE_HIGH;
87 break;
88
89 default:
90 assert(0);
91 break;
92 }
93
94 result.level = dec->base.level;
95
96 result.sps_info_flags = 0;
97 result.sps_info_flags |= pic->pps->sps->direct_8x8_inference_flag << 0;
98 result.sps_info_flags |= pic->pps->sps->mb_adaptive_frame_field_flag << 1;
99 result.sps_info_flags |= pic->pps->sps->frame_mbs_only_flag << 2;
100 result.sps_info_flags |= pic->pps->sps->delta_pic_order_always_zero_flag << 3;
101 result.sps_info_flags |= ((dec->dpb_type == DPB_DYNAMIC_TIER_2) ? 0 : 1)
102 << RDECODE_SPS_INFO_H264_EXTENSION_SUPPORT_FLAG_SHIFT;
103
104 result.bit_depth_luma_minus8 = pic->pps->sps->bit_depth_luma_minus8;
105 result.bit_depth_chroma_minus8 = pic->pps->sps->bit_depth_chroma_minus8;
106 result.log2_max_frame_num_minus4 = pic->pps->sps->log2_max_frame_num_minus4;
107 result.pic_order_cnt_type = pic->pps->sps->pic_order_cnt_type;
108 result.log2_max_pic_order_cnt_lsb_minus4 = pic->pps->sps->log2_max_pic_order_cnt_lsb_minus4;
109
110 switch (dec->base.chroma_format) {
111 case PIPE_VIDEO_CHROMA_FORMAT_NONE:
112 break;
113 case PIPE_VIDEO_CHROMA_FORMAT_400:
114 result.chroma_format = 0;
115 break;
116 case PIPE_VIDEO_CHROMA_FORMAT_420:
117 result.chroma_format = 1;
118 break;
119 case PIPE_VIDEO_CHROMA_FORMAT_422:
120 result.chroma_format = 2;
121 break;
122 case PIPE_VIDEO_CHROMA_FORMAT_444:
123 result.chroma_format = 3;
124 break;
125 }
126
127 result.pps_info_flags = 0;
128 result.pps_info_flags |= pic->pps->transform_8x8_mode_flag << 0;
129 result.pps_info_flags |= pic->pps->redundant_pic_cnt_present_flag << 1;
130 result.pps_info_flags |= pic->pps->constrained_intra_pred_flag << 2;
131 result.pps_info_flags |= pic->pps->deblocking_filter_control_present_flag << 3;
132 result.pps_info_flags |= pic->pps->weighted_bipred_idc << 4;
133 result.pps_info_flags |= pic->pps->weighted_pred_flag << 6;
134 result.pps_info_flags |= pic->pps->bottom_field_pic_order_in_frame_present_flag << 7;
135 result.pps_info_flags |= pic->pps->entropy_coding_mode_flag << 8;
136
137 result.num_slice_groups_minus1 = pic->pps->num_slice_groups_minus1;
138 result.slice_group_map_type = pic->pps->slice_group_map_type;
139 result.slice_group_change_rate_minus1 = pic->pps->slice_group_change_rate_minus1;
140 result.pic_init_qp_minus26 = pic->pps->pic_init_qp_minus26;
141 result.chroma_qp_index_offset = pic->pps->chroma_qp_index_offset;
142 result.second_chroma_qp_index_offset = pic->pps->second_chroma_qp_index_offset;
143
144 memcpy(result.scaling_list_4x4, pic->pps->ScalingList4x4, 6 * 16);
145 memcpy(result.scaling_list_8x8, pic->pps->ScalingList8x8, 2 * 64);
146
147 memcpy(dec->it, result.scaling_list_4x4, 6 * 16);
148 memcpy((dec->it + 96), result.scaling_list_8x8, 2 * 64);
149
150 result.num_ref_frames = pic->num_ref_frames;
151
152 result.num_ref_idx_l0_active_minus1 = pic->num_ref_idx_l0_active_minus1;
153 result.num_ref_idx_l1_active_minus1 = pic->num_ref_idx_l1_active_minus1;
154
155 result.frame_num = pic->frame_num;
156 memcpy(result.frame_num_list, pic->frame_num_list, 4 * 16);
157 result.curr_field_order_cnt_list[0] = pic->field_order_cnt[0];
158 result.curr_field_order_cnt_list[1] = pic->field_order_cnt[1];
159 memcpy(result.field_order_cnt_list, pic->field_order_cnt_list, 4 * 16 * 2);
160 result.non_existing_frame_flags = 0;
161 result.used_for_reference_flags = 0;
162
163 if (dec->dpb_type != DPB_DYNAMIC_TIER_2) {
164 result.decoded_pic_idx = pic->frame_num;
165 goto end;
166 }
167
168 private = pic->priv;
169 for (i = 0; i < ARRAY_SIZE(private->past_ref); i++) {
170 for (k = 0; private->past_ref[i] && (k < ARRAY_SIZE(pic->ref)); k++)
171 if (pic->ref[k] && (private->past_ref[i] == pic->ref[k]))
172 break;
173
174 for (j = 0; private->past_ref[i]
175 && (k == ARRAY_SIZE(pic->ref))
176 && (j < ARRAY_SIZE(dec->render_pic_list)); j++) {
177 if (dec->render_pic_list[j]
178 && (dec->render_pic_list[j] == private->past_ref[i])) {
179 dec->render_pic_list[j] = pic->ref[i];
180 vl_video_buffer_set_associated_data(pic->ref[i], &dec->base,
181 (void *)(uintptr_t)j, &radeon_dec_destroy_associated_data);
182 break;
183 }
184 }
185 }
186
187 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); i++) {
188 for (j = 0; (pic->ref[j] != NULL) && (j < ARRAY_SIZE(dec->render_pic_list)); j++) {
189 if (dec->render_pic_list[i] == pic->ref[j])
190 break;
191 if (j == ARRAY_SIZE(dec->render_pic_list) - 1)
192 dec->render_pic_list[i] = NULL;
193 else if (pic->ref[j + 1] == NULL)
194 dec->render_pic_list[i] = NULL;
195 }
196 }
197 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); ++i) {
198 if (dec->render_pic_list[i] && dec->render_pic_list[i] == target) {
199 if (target->codec != NULL){
200 result.decoded_pic_idx =
201 (uintptr_t)vl_video_buffer_get_associated_data(target, &dec->base);
202 } else {
203 result.decoded_pic_idx = i;
204 vl_video_buffer_set_associated_data(target, &dec->base, (void *)(uintptr_t)i,
205 &radeon_dec_destroy_associated_data);
206 }
207 break;
208 }
209 }
210 if (i == ARRAY_SIZE(dec->render_pic_list)) {
211 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); ++i) {
212 if (!dec->render_pic_list[i]) {
213 dec->render_pic_list[i] = target;
214 result.decoded_pic_idx = i;
215 vl_video_buffer_set_associated_data(target, &dec->base, (void *)(uintptr_t)i,
216 &radeon_dec_destroy_associated_data);
217 break;
218 }
219 }
220 }
221 for (i = 0; i < ARRAY_SIZE(result.ref_frame_list); i++) {
222 result.ref_frame_list[i] = pic->ref[i] ?
223 (uintptr_t)vl_video_buffer_get_associated_data(pic->ref[i], &dec->base) : 0xff;
224
225 if (result.ref_frame_list[i] != 0xff) {
226 if (pic->top_is_reference[i])
227 result.used_for_reference_flags |= (1 << (2 * i));
228 if (pic->bottom_is_reference[i])
229 result.used_for_reference_flags |= (1 << (2 * i + 1));
230
231 if (pic->is_long_term[i])
232 result.ref_frame_list[i] |= 0x80;
233
234 result.curr_pic_ref_frame_num++;
235
236 for (j = 0; j < ARRAY_SIZE(dec->h264_valid_ref_num); j++) {
237 if ((dec->h264_valid_ref_num[j] != (unsigned)-1)
238 && (dec->h264_valid_ref_num[j] == result.frame_num_list[i]))
239 break;
240 }
241
242 for (k = 0; k < ARRAY_SIZE(dec->h264_valid_poc_num); k++) {
243 if ((dec->h264_valid_poc_num[k] != (unsigned)-1)
244 && ((dec->h264_valid_poc_num[k] == result.field_order_cnt_list[i][0])
245 || dec->h264_valid_poc_num[k] == result.field_order_cnt_list[i][1]))
246 break;
247 }
248 }
249 if (result.ref_frame_list[i] != 0xff && (j == ARRAY_SIZE(dec->h264_valid_ref_num))
250 && (k == ARRAY_SIZE(dec->h264_valid_poc_num))) {
251 result.non_existing_frame_flags |= 1 << i;
252 result.curr_pic_ref_frame_num--;
253 result.ref_frame_list[i] = 0xff;
254 }
255 }
256
257 for (i = 0; i < ARRAY_SIZE(result.ref_frame_list); i++) {
258 if (result.ref_frame_list[i] != 0xff) {
259 dec->h264_valid_ref_num[i] = result.frame_num_list[i];
260 dec->h264_valid_poc_num[2 * i] = pic->top_is_reference[i] ?
261 result.field_order_cnt_list[i][0] : (unsigned) -1;
262 dec->h264_valid_poc_num[2 * i + 1] = pic->bottom_is_reference[i] ?
263 result.field_order_cnt_list[i][1] : (unsigned) -1;
264 } else {
265 dec->h264_valid_ref_num[i] =
266 dec->h264_valid_poc_num[2 * i] =
267 dec->h264_valid_poc_num[2 * i + 1] = (unsigned) -1;
268 }
269 }
270
271 dec->h264_valid_ref_num[ARRAY_SIZE(dec->h264_valid_ref_num) - 1] = result.frame_num;
272 dec->h264_valid_poc_num[ARRAY_SIZE(dec->h264_valid_poc_num) - 2] =
273 pic->field_pic_flag && pic->bottom_field_flag ?
274 (unsigned) -1 : result.curr_field_order_cnt_list[0];
275 dec->h264_valid_poc_num[ARRAY_SIZE(dec->h264_valid_poc_num) - 1] =
276 pic->field_pic_flag && !pic->bottom_field_flag ?
277 (unsigned) -1 : result.curr_field_order_cnt_list[1];
278
279 if (dec->dpb_type == DPB_DYNAMIC_TIER_2) {
280 dec->ref_codec.bts = CODEC_8_BITS;
281 dec->ref_codec.index = result.decoded_pic_idx;
282 dec->ref_codec.ref_size = 16;
283 memset(dec->ref_codec.ref_list, 0xff, sizeof(dec->ref_codec.ref_list));
284 memcpy(dec->ref_codec.ref_list, result.ref_frame_list, sizeof(result.ref_frame_list));
285 }
286
287 end:
288 return result;
289 }
290
get_h265_msg(struct radeon_decoder *dec, struct pipe_video_buffer *target, struct pipe_h265_picture_desc *pic)291 static rvcn_dec_message_hevc_t get_h265_msg(struct radeon_decoder *dec,
292 struct pipe_video_buffer *target,
293 struct pipe_h265_picture_desc *pic)
294 {
295 rvcn_dec_message_hevc_t result;
296 unsigned i, j;
297
298 memset(&result, 0, sizeof(result));
299 result.sps_info_flags = 0;
300 result.sps_info_flags |= pic->pps->sps->scaling_list_enabled_flag << 0;
301 result.sps_info_flags |= pic->pps->sps->amp_enabled_flag << 1;
302 result.sps_info_flags |= pic->pps->sps->sample_adaptive_offset_enabled_flag << 2;
303 result.sps_info_flags |= pic->pps->sps->pcm_enabled_flag << 3;
304 result.sps_info_flags |= pic->pps->sps->pcm_loop_filter_disabled_flag << 4;
305 result.sps_info_flags |= pic->pps->sps->long_term_ref_pics_present_flag << 5;
306 result.sps_info_flags |= pic->pps->sps->sps_temporal_mvp_enabled_flag << 6;
307 result.sps_info_flags |= pic->pps->sps->strong_intra_smoothing_enabled_flag << 7;
308 result.sps_info_flags |= pic->pps->sps->separate_colour_plane_flag << 8;
309 if (((struct si_screen *)dec->screen)->info.family == CHIP_CARRIZO)
310 result.sps_info_flags |= 1 << 9;
311 if (pic->UseRefPicList == true)
312 result.sps_info_flags |= 1 << 10;
313 if (pic->UseStRpsBits == true && pic->pps->st_rps_bits != 0) {
314 result.sps_info_flags |= 1 << 11;
315 result.st_rps_bits = pic->pps->st_rps_bits;
316 }
317
318 result.chroma_format = pic->pps->sps->chroma_format_idc;
319 result.bit_depth_luma_minus8 = pic->pps->sps->bit_depth_luma_minus8;
320 result.bit_depth_chroma_minus8 = pic->pps->sps->bit_depth_chroma_minus8;
321 result.log2_max_pic_order_cnt_lsb_minus4 = pic->pps->sps->log2_max_pic_order_cnt_lsb_minus4;
322 result.sps_max_dec_pic_buffering_minus1 = pic->pps->sps->sps_max_dec_pic_buffering_minus1;
323 result.log2_min_luma_coding_block_size_minus3 =
324 pic->pps->sps->log2_min_luma_coding_block_size_minus3;
325 result.log2_diff_max_min_luma_coding_block_size =
326 pic->pps->sps->log2_diff_max_min_luma_coding_block_size;
327 result.log2_min_transform_block_size_minus2 =
328 pic->pps->sps->log2_min_transform_block_size_minus2;
329 result.log2_diff_max_min_transform_block_size =
330 pic->pps->sps->log2_diff_max_min_transform_block_size;
331 result.max_transform_hierarchy_depth_inter = pic->pps->sps->max_transform_hierarchy_depth_inter;
332 result.max_transform_hierarchy_depth_intra = pic->pps->sps->max_transform_hierarchy_depth_intra;
333 result.pcm_sample_bit_depth_luma_minus1 = pic->pps->sps->pcm_sample_bit_depth_luma_minus1;
334 result.pcm_sample_bit_depth_chroma_minus1 = pic->pps->sps->pcm_sample_bit_depth_chroma_minus1;
335 result.log2_min_pcm_luma_coding_block_size_minus3 =
336 pic->pps->sps->log2_min_pcm_luma_coding_block_size_minus3;
337 result.log2_diff_max_min_pcm_luma_coding_block_size =
338 pic->pps->sps->log2_diff_max_min_pcm_luma_coding_block_size;
339 result.num_short_term_ref_pic_sets = pic->pps->sps->num_short_term_ref_pic_sets;
340
341 result.pps_info_flags = 0;
342 result.pps_info_flags |= pic->pps->dependent_slice_segments_enabled_flag << 0;
343 result.pps_info_flags |= pic->pps->output_flag_present_flag << 1;
344 result.pps_info_flags |= pic->pps->sign_data_hiding_enabled_flag << 2;
345 result.pps_info_flags |= pic->pps->cabac_init_present_flag << 3;
346 result.pps_info_flags |= pic->pps->constrained_intra_pred_flag << 4;
347 result.pps_info_flags |= pic->pps->transform_skip_enabled_flag << 5;
348 result.pps_info_flags |= pic->pps->cu_qp_delta_enabled_flag << 6;
349 result.pps_info_flags |= pic->pps->pps_slice_chroma_qp_offsets_present_flag << 7;
350 result.pps_info_flags |= pic->pps->weighted_pred_flag << 8;
351 result.pps_info_flags |= pic->pps->weighted_bipred_flag << 9;
352 result.pps_info_flags |= pic->pps->transquant_bypass_enabled_flag << 10;
353 result.pps_info_flags |= pic->pps->tiles_enabled_flag << 11;
354 result.pps_info_flags |= pic->pps->entropy_coding_sync_enabled_flag << 12;
355 result.pps_info_flags |= pic->pps->uniform_spacing_flag << 13;
356 result.pps_info_flags |= pic->pps->loop_filter_across_tiles_enabled_flag << 14;
357 result.pps_info_flags |= pic->pps->pps_loop_filter_across_slices_enabled_flag << 15;
358 result.pps_info_flags |= pic->pps->deblocking_filter_override_enabled_flag << 16;
359 result.pps_info_flags |= pic->pps->pps_deblocking_filter_disabled_flag << 17;
360 result.pps_info_flags |= pic->pps->lists_modification_present_flag << 18;
361 result.pps_info_flags |= pic->pps->slice_segment_header_extension_present_flag << 19;
362
363 result.num_extra_slice_header_bits = pic->pps->num_extra_slice_header_bits;
364 result.num_long_term_ref_pic_sps = pic->pps->sps->num_long_term_ref_pics_sps;
365 result.num_ref_idx_l0_default_active_minus1 = pic->pps->num_ref_idx_l0_default_active_minus1;
366 result.num_ref_idx_l1_default_active_minus1 = pic->pps->num_ref_idx_l1_default_active_minus1;
367 result.pps_cb_qp_offset = pic->pps->pps_cb_qp_offset;
368 result.pps_cr_qp_offset = pic->pps->pps_cr_qp_offset;
369 result.pps_beta_offset_div2 = pic->pps->pps_beta_offset_div2;
370 result.pps_tc_offset_div2 = pic->pps->pps_tc_offset_div2;
371 result.diff_cu_qp_delta_depth = pic->pps->diff_cu_qp_delta_depth;
372 result.num_tile_columns_minus1 = pic->pps->num_tile_columns_minus1;
373 result.num_tile_rows_minus1 = pic->pps->num_tile_rows_minus1;
374 result.log2_parallel_merge_level_minus2 = pic->pps->log2_parallel_merge_level_minus2;
375 result.init_qp_minus26 = pic->pps->init_qp_minus26;
376
377 for (i = 0; i < 19; ++i)
378 result.column_width_minus1[i] = pic->pps->column_width_minus1[i];
379
380 for (i = 0; i < 21; ++i)
381 result.row_height_minus1[i] = pic->pps->row_height_minus1[i];
382
383 result.num_delta_pocs_ref_rps_idx = pic->NumDeltaPocsOfRefRpsIdx;
384 result.curr_poc = pic->CurrPicOrderCntVal;
385
386 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); i++) {
387 for (j = 0;
388 (pic->ref[j] != NULL) && (j < ARRAY_SIZE(dec->render_pic_list));
389 j++) {
390 if (dec->render_pic_list[i] == pic->ref[j])
391 break;
392 if (j == ARRAY_SIZE(dec->render_pic_list) - 1)
393 dec->render_pic_list[i] = NULL;
394 else if (pic->ref[j + 1] == NULL)
395 dec->render_pic_list[i] = NULL;
396 }
397 }
398 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); i++) {
399 if (dec->render_pic_list[i] == NULL) {
400 dec->render_pic_list[i] = target;
401 result.curr_idx = i;
402 break;
403 }
404 }
405
406 vl_video_buffer_set_associated_data(target, &dec->base, (void *)(uintptr_t)result.curr_idx,
407 &radeon_dec_destroy_associated_data);
408
409 for (i = 0; i < 16; ++i) {
410 struct pipe_video_buffer *ref = pic->ref[i];
411 uintptr_t ref_pic = 0;
412
413 result.poc_list[i] = pic->PicOrderCntVal[i];
414
415 if (ref)
416 ref_pic = (uintptr_t)vl_video_buffer_get_associated_data(ref, &dec->base);
417 else
418 ref_pic = 0x7F;
419 result.ref_pic_list[i] = ref_pic;
420 }
421
422 for (i = 0; i < 8; ++i) {
423 result.ref_pic_set_st_curr_before[i] = 0xFF;
424 result.ref_pic_set_st_curr_after[i] = 0xFF;
425 result.ref_pic_set_lt_curr[i] = 0xFF;
426 }
427
428 for (i = 0; i < pic->NumPocStCurrBefore; ++i)
429 result.ref_pic_set_st_curr_before[i] = pic->RefPicSetStCurrBefore[i];
430
431 for (i = 0; i < pic->NumPocStCurrAfter; ++i)
432 result.ref_pic_set_st_curr_after[i] = pic->RefPicSetStCurrAfter[i];
433
434 for (i = 0; i < pic->NumPocLtCurr; ++i)
435 result.ref_pic_set_lt_curr[i] = pic->RefPicSetLtCurr[i];
436
437 for (i = 0; i < 6; ++i)
438 result.ucScalingListDCCoefSizeID2[i] = pic->pps->sps->ScalingListDCCoeff16x16[i];
439
440 for (i = 0; i < 2; ++i)
441 result.ucScalingListDCCoefSizeID3[i] = pic->pps->sps->ScalingListDCCoeff32x32[i];
442
443 memcpy(dec->it, pic->pps->sps->ScalingList4x4, 6 * 16);
444 memcpy(dec->it + 96, pic->pps->sps->ScalingList8x8, 6 * 64);
445 memcpy(dec->it + 480, pic->pps->sps->ScalingList16x16, 6 * 64);
446 memcpy(dec->it + 864, pic->pps->sps->ScalingList32x32, 2 * 64);
447
448 for (i = 0; i < 2; i++) {
449 for (j = 0; j < 15; j++)
450 result.direct_reflist[i][j] = pic->RefPicList[i][j];
451 }
452
453 if (pic->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10) {
454 if (target->buffer_format == PIPE_FORMAT_P010 || target->buffer_format == PIPE_FORMAT_P016) {
455 result.p010_mode = 1;
456 result.msb_mode = 1;
457 } else {
458 result.p010_mode = 0;
459 result.luma_10to8 = 5;
460 result.chroma_10to8 = 5;
461 result.hevc_reserved[0] = 4; /* sclr_luma10to8 */
462 result.hevc_reserved[1] = 4; /* sclr_chroma10to8 */
463 }
464 }
465
466 if (dec->dpb_type == DPB_DYNAMIC_TIER_2) {
467 dec->ref_codec.bts = (pic->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10) ?
468 CODEC_10_BITS : CODEC_8_BITS;
469 dec->ref_codec.index = result.curr_idx;
470 dec->ref_codec.ref_size = 15;
471 memset(dec->ref_codec.ref_list, 0x7f, sizeof(dec->ref_codec.ref_list));
472 memcpy(dec->ref_codec.ref_list, result.ref_pic_list, sizeof(result.ref_pic_list));
473 }
474 return result;
475 }
476
fill_probs_table(void *ptr)477 static void fill_probs_table(void *ptr)
478 {
479 rvcn_dec_vp9_probs_t *probs = (rvcn_dec_vp9_probs_t *)ptr;
480
481 memcpy(&probs->coef_probs[0], default_coef_probs_4x4, sizeof(default_coef_probs_4x4));
482 memcpy(&probs->coef_probs[1], default_coef_probs_8x8, sizeof(default_coef_probs_8x8));
483 memcpy(&probs->coef_probs[2], default_coef_probs_16x16, sizeof(default_coef_probs_16x16));
484 memcpy(&probs->coef_probs[3], default_coef_probs_32x32, sizeof(default_coef_probs_32x32));
485 memcpy(probs->y_mode_prob, default_if_y_probs, sizeof(default_if_y_probs));
486 memcpy(probs->uv_mode_prob, default_if_uv_probs, sizeof(default_if_uv_probs));
487 memcpy(probs->single_ref_prob, default_single_ref_p, sizeof(default_single_ref_p));
488 memcpy(probs->switchable_interp_prob, default_switchable_interp_prob,
489 sizeof(default_switchable_interp_prob));
490 memcpy(probs->partition_prob, default_partition_probs, sizeof(default_partition_probs));
491 memcpy(probs->inter_mode_probs, default_inter_mode_probs, sizeof(default_inter_mode_probs));
492 memcpy(probs->mbskip_probs, default_skip_probs, sizeof(default_skip_probs));
493 memcpy(probs->intra_inter_prob, default_intra_inter_p, sizeof(default_intra_inter_p));
494 memcpy(probs->comp_inter_prob, default_comp_inter_p, sizeof(default_comp_inter_p));
495 memcpy(probs->comp_ref_prob, default_comp_ref_p, sizeof(default_comp_ref_p));
496 memcpy(probs->tx_probs_32x32, default_tx_probs_32x32, sizeof(default_tx_probs_32x32));
497 memcpy(probs->tx_probs_16x16, default_tx_probs_16x16, sizeof(default_tx_probs_16x16));
498 memcpy(probs->tx_probs_8x8, default_tx_probs_8x8, sizeof(default_tx_probs_8x8));
499 memcpy(probs->mv_joints, default_nmv_joints, sizeof(default_nmv_joints));
500 memcpy(&probs->mv_comps[0], default_nmv_components, sizeof(default_nmv_components));
501 memset(&probs->nmvc_mask, 0, sizeof(rvcn_dec_vp9_nmv_ctx_mask_t));
502 }
503
get_vp9_msg(struct radeon_decoder *dec, struct pipe_video_buffer *target, struct pipe_vp9_picture_desc *pic)504 static rvcn_dec_message_vp9_t get_vp9_msg(struct radeon_decoder *dec,
505 struct pipe_video_buffer *target,
506 struct pipe_vp9_picture_desc *pic)
507 {
508 rvcn_dec_message_vp9_t result;
509 unsigned i ,j;
510
511 memset(&result, 0, sizeof(result));
512
513 /* segment table */
514 rvcn_dec_vp9_probs_segment_t *prbs = (rvcn_dec_vp9_probs_segment_t *)(dec->probs);
515
516 if (pic->picture_parameter.pic_fields.segmentation_enabled) {
517 for (i = 0; i < 8; ++i) {
518 prbs->seg.feature_data[i] =
519 (pic->slice_parameter.seg_param[i].alt_quant & 0xffff) |
520 ((pic->slice_parameter.seg_param[i].alt_lf & 0xff) << 16) |
521 ((pic->slice_parameter.seg_param[i].segment_flags.segment_reference & 0xf) << 24);
522 prbs->seg.feature_mask[i] =
523 (pic->slice_parameter.seg_param[i].alt_quant_enabled << 0) |
524 (pic->slice_parameter.seg_param[i].alt_lf_enabled << 1) |
525 (pic->slice_parameter.seg_param[i].segment_flags.segment_reference_enabled << 2) |
526 (pic->slice_parameter.seg_param[i].segment_flags.segment_reference_skipped << 3);
527 }
528
529 for (i = 0; i < 7; ++i)
530 prbs->seg.tree_probs[i] = pic->picture_parameter.mb_segment_tree_probs[i];
531
532 for (i = 0; i < 3; ++i)
533 prbs->seg.pred_probs[i] = pic->picture_parameter.segment_pred_probs[i];
534
535 prbs->seg.abs_delta = pic->picture_parameter.abs_delta;
536 } else
537 memset(&prbs->seg, 0, 256);
538
539 result.frame_header_flags = (pic->picture_parameter.pic_fields.frame_type
540 << RDECODE_FRAME_HDR_INFO_VP9_FRAME_TYPE_SHIFT) &
541 RDECODE_FRAME_HDR_INFO_VP9_FRAME_TYPE_MASK;
542
543 result.frame_header_flags |= (pic->picture_parameter.pic_fields.error_resilient_mode
544 << RDECODE_FRAME_HDR_INFO_VP9_ERROR_RESILIENT_MODE_SHIFT) &
545 RDECODE_FRAME_HDR_INFO_VP9_ERROR_RESILIENT_MODE_MASK;
546
547 result.frame_header_flags |= (pic->picture_parameter.pic_fields.intra_only
548 << RDECODE_FRAME_HDR_INFO_VP9_INTRA_ONLY_SHIFT) &
549 RDECODE_FRAME_HDR_INFO_VP9_INTRA_ONLY_MASK;
550
551 result.frame_header_flags |= (pic->picture_parameter.pic_fields.allow_high_precision_mv
552 << RDECODE_FRAME_HDR_INFO_VP9_ALLOW_HIGH_PRECISION_MV_SHIFT) &
553 RDECODE_FRAME_HDR_INFO_VP9_ALLOW_HIGH_PRECISION_MV_MASK;
554
555 result.frame_header_flags |= (pic->picture_parameter.pic_fields.frame_parallel_decoding_mode
556 << RDECODE_FRAME_HDR_INFO_VP9_FRAME_PARALLEL_DECODING_MODE_SHIFT) &
557 RDECODE_FRAME_HDR_INFO_VP9_FRAME_PARALLEL_DECODING_MODE_MASK;
558
559 result.frame_header_flags |= (pic->picture_parameter.pic_fields.refresh_frame_context
560 << RDECODE_FRAME_HDR_INFO_VP9_REFRESH_FRAME_CONTEXT_SHIFT) &
561 RDECODE_FRAME_HDR_INFO_VP9_REFRESH_FRAME_CONTEXT_MASK;
562
563 result.frame_header_flags |= (pic->picture_parameter.pic_fields.segmentation_enabled
564 << RDECODE_FRAME_HDR_INFO_VP9_SEGMENTATION_ENABLED_SHIFT) &
565 RDECODE_FRAME_HDR_INFO_VP9_SEGMENTATION_ENABLED_MASK;
566
567 result.frame_header_flags |= (pic->picture_parameter.pic_fields.segmentation_update_map
568 << RDECODE_FRAME_HDR_INFO_VP9_SEGMENTATION_UPDATE_MAP_SHIFT) &
569 RDECODE_FRAME_HDR_INFO_VP9_SEGMENTATION_UPDATE_MAP_MASK;
570
571 result.frame_header_flags |= (pic->picture_parameter.pic_fields.segmentation_temporal_update
572 << RDECODE_FRAME_HDR_INFO_VP9_SEGMENTATION_TEMPORAL_UPDATE_SHIFT) &
573 RDECODE_FRAME_HDR_INFO_VP9_SEGMENTATION_TEMPORAL_UPDATE_MASK;
574
575 result.frame_header_flags |= (pic->picture_parameter.mode_ref_delta_enabled
576 << RDECODE_FRAME_HDR_INFO_VP9_MODE_REF_DELTA_ENABLED_SHIFT) &
577 RDECODE_FRAME_HDR_INFO_VP9_MODE_REF_DELTA_ENABLED_MASK;
578
579 result.frame_header_flags |= (pic->picture_parameter.mode_ref_delta_update
580 << RDECODE_FRAME_HDR_INFO_VP9_MODE_REF_DELTA_UPDATE_SHIFT) &
581 RDECODE_FRAME_HDR_INFO_VP9_MODE_REF_DELTA_UPDATE_MASK;
582
583 result.frame_header_flags |=
584 ((dec->show_frame && !pic->picture_parameter.pic_fields.error_resilient_mode &&
585 dec->last_width == dec->base.width && dec->last_height == dec->base.height)
586 << RDECODE_FRAME_HDR_INFO_VP9_USE_PREV_IN_FIND_MV_REFS_SHIFT) &
587 RDECODE_FRAME_HDR_INFO_VP9_USE_PREV_IN_FIND_MV_REFS_MASK;
588 dec->show_frame = pic->picture_parameter.pic_fields.show_frame;
589
590 result.frame_header_flags |= (1 << RDECODE_FRAME_HDR_INFO_VP9_USE_UNCOMPRESSED_HEADER_SHIFT) &
591 RDECODE_FRAME_HDR_INFO_VP9_USE_UNCOMPRESSED_HEADER_MASK;
592
593 result.interp_filter = pic->picture_parameter.pic_fields.mcomp_filter_type;
594
595 result.frame_context_idx = pic->picture_parameter.pic_fields.frame_context_idx;
596 result.reset_frame_context = pic->picture_parameter.pic_fields.reset_frame_context;
597
598 result.filter_level = pic->picture_parameter.filter_level;
599 result.sharpness_level = pic->picture_parameter.sharpness_level;
600
601 for (i = 0; i < 8; ++i)
602 memcpy(result.lf_adj_level[i], pic->slice_parameter.seg_param[i].filter_level, 4 * 2);
603
604 if (pic->picture_parameter.pic_fields.lossless_flag) {
605 result.base_qindex = 0;
606 result.y_dc_delta_q = 0;
607 result.uv_ac_delta_q = 0;
608 result.uv_dc_delta_q = 0;
609 } else {
610 result.base_qindex = pic->picture_parameter.base_qindex;
611 result.y_dc_delta_q = pic->picture_parameter.y_dc_delta_q;
612 result.uv_ac_delta_q = pic->picture_parameter.uv_ac_delta_q;
613 result.uv_dc_delta_q = pic->picture_parameter.uv_dc_delta_q;
614 }
615
616 result.log2_tile_cols = pic->picture_parameter.log2_tile_columns;
617 result.log2_tile_rows = pic->picture_parameter.log2_tile_rows;
618 result.chroma_format = 1;
619 result.bit_depth_luma_minus8 = result.bit_depth_chroma_minus8 =
620 (pic->picture_parameter.bit_depth - 8);
621
622 result.vp9_frame_size = align(dec->bs_size, 128);
623 result.uncompressed_header_size = pic->picture_parameter.frame_header_length_in_bytes;
624 result.compressed_header_size = pic->picture_parameter.first_partition_size;
625
626 assert(dec->base.max_references + 1 <= ARRAY_SIZE(dec->render_pic_list));
627
628 //clear the dec->render list if it is not used as a reference
629 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); i++) {
630 if (dec->render_pic_list[i]) {
631 for (j=0;j<8;j++) {
632 if (dec->render_pic_list[i] == pic->ref[j])
633 break;
634 }
635 if (j == 8)
636 dec->render_pic_list[i] = NULL;
637 }
638 }
639
640 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); ++i) {
641 if (dec->render_pic_list[i] && dec->render_pic_list[i] == target) {
642 if (target->codec != NULL) {
643 result.curr_pic_idx =(uintptr_t)vl_video_buffer_get_associated_data(target, &dec->base);
644 } else {
645 result.curr_pic_idx = i;
646 vl_video_buffer_set_associated_data(target, &dec->base, (void *)(uintptr_t)i,
647 &radeon_dec_destroy_associated_data);
648 }
649 break;
650 } else if (!dec->render_pic_list[i]) {
651 dec->render_pic_list[i] = target;
652 result.curr_pic_idx = i;
653 vl_video_buffer_set_associated_data(target, &dec->base, (void *)(uintptr_t)i,
654 &radeon_dec_destroy_associated_data);
655 break;
656 }
657 }
658
659 for (i = 0; i < 8; i++) {
660 result.ref_frame_map[i] =
661 (pic->ref[i]) ? (uintptr_t)vl_video_buffer_get_associated_data(pic->ref[i], &dec->base)
662 : 0x7f;
663 }
664
665 result.frame_refs[0] = result.ref_frame_map[pic->picture_parameter.pic_fields.last_ref_frame];
666 result.ref_frame_sign_bias[0] = pic->picture_parameter.pic_fields.last_ref_frame_sign_bias;
667 result.frame_refs[1] = result.ref_frame_map[pic->picture_parameter.pic_fields.golden_ref_frame];
668 result.ref_frame_sign_bias[1] = pic->picture_parameter.pic_fields.golden_ref_frame_sign_bias;
669 result.frame_refs[2] = result.ref_frame_map[pic->picture_parameter.pic_fields.alt_ref_frame];
670 result.ref_frame_sign_bias[2] = pic->picture_parameter.pic_fields.alt_ref_frame_sign_bias;
671
672 if (pic->base.profile == PIPE_VIDEO_PROFILE_VP9_PROFILE2) {
673 if (target->buffer_format == PIPE_FORMAT_P010 || target->buffer_format == PIPE_FORMAT_P016) {
674 result.p010_mode = 1;
675 result.msb_mode = 1;
676 } else {
677 result.p010_mode = 0;
678 result.luma_10to8 = 1;
679 result.chroma_10to8 = 1;
680 }
681 }
682
683 if (dec->dpb_type == DPB_DYNAMIC_TIER_2) {
684 dec->ref_codec.bts = (pic->base.profile == PIPE_VIDEO_PROFILE_VP9_PROFILE2) ?
685 CODEC_10_BITS : CODEC_8_BITS;
686 dec->ref_codec.index = result.curr_pic_idx;
687 dec->ref_codec.ref_size = 8;
688 memset(dec->ref_codec.ref_list, 0x7f, sizeof(dec->ref_codec.ref_list));
689 memcpy(dec->ref_codec.ref_list, result.ref_frame_map, sizeof(result.ref_frame_map));
690 }
691
692 dec->last_width = dec->base.width;
693 dec->last_height = dec->base.height;
694
695 return result;
696 }
697
set_drm_keys(rvcn_dec_message_drm_t *drm, DECRYPT_PARAMETERS *decrypted)698 static void set_drm_keys(rvcn_dec_message_drm_t *drm, DECRYPT_PARAMETERS *decrypted)
699 {
700 int cbc = decrypted->u.s.cbc;
701 int ctr = decrypted->u.s.ctr;
702 int id = decrypted->u.s.drm_id;
703 int ekc = 1;
704 int data1 = 1;
705 int data2 = 1;
706
707 drm->drm_cmd = 0;
708 drm->drm_cntl = 0;
709
710 drm->drm_cntl = 1 << DRM_CNTL_BYPASS_SHIFT;
711
712 if (cbc || ctr) {
713 drm->drm_cntl = 0 << DRM_CNTL_BYPASS_SHIFT;
714 drm->drm_cmd |= 0xff << DRM_CMD_BYTE_MASK_SHIFT;
715
716 if (ctr)
717 drm->drm_cmd |= 0x00 << DRM_CMD_ALGORITHM_SHIFT;
718 else if (cbc)
719 drm->drm_cmd |= 0x02 << DRM_CMD_ALGORITHM_SHIFT;
720
721 drm->drm_cmd |= 1 << DRM_CMD_GEN_MASK_SHIFT;
722 drm->drm_cmd |= ekc << DRM_CMD_UNWRAP_KEY_SHIFT;
723 drm->drm_cmd |= 0 << DRM_CMD_OFFSET_SHIFT;
724 drm->drm_cmd |= data2 << DRM_CMD_CNT_DATA_SHIFT;
725 drm->drm_cmd |= data1 << DRM_CMD_CNT_KEY_SHIFT;
726 drm->drm_cmd |= ekc << DRM_CMD_KEY_SHIFT;
727 drm->drm_cmd |= id << DRM_CMD_SESSION_SEL_SHIFT;
728
729 if (ekc)
730 memcpy(drm->drm_wrapped_key, decrypted->encrypted_key, 16);
731 if (data1)
732 memcpy(drm->drm_key, decrypted->session_iv, 16);
733 if (data2)
734 memcpy(drm->drm_counter, decrypted->encrypted_iv, 16);
735 drm->drm_offset = 0;
736 }
737 }
738
get_av1_msg(struct radeon_decoder *dec, struct pipe_video_buffer *target, struct pipe_av1_picture_desc *pic)739 static rvcn_dec_message_av1_t get_av1_msg(struct radeon_decoder *dec,
740 struct pipe_video_buffer *target,
741 struct pipe_av1_picture_desc *pic)
742 {
743 rvcn_dec_message_av1_t result;
744 unsigned i, j;
745
746 memset(&result, 0, sizeof(result));
747
748 result.frame_header_flags = (pic->picture_parameter.pic_info_fields.show_frame
749 << RDECODE_FRAME_HDR_INFO_AV1_SHOW_FRAME_SHIFT) &
750 RDECODE_FRAME_HDR_INFO_AV1_SHOW_FRAME_MASK;
751
752 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.disable_cdf_update
753 << RDECODE_FRAME_HDR_INFO_AV1_DISABLE_CDF_UPDATE_SHIFT) &
754 RDECODE_FRAME_HDR_INFO_AV1_DISABLE_CDF_UPDATE_MASK;
755
756 result.frame_header_flags |= ((!pic->picture_parameter.pic_info_fields.disable_frame_end_update_cdf)
757 << RDECODE_FRAME_HDR_INFO_AV1_REFRESH_FRAME_CONTEXT_SHIFT) &
758 RDECODE_FRAME_HDR_INFO_AV1_REFRESH_FRAME_CONTEXT_MASK;
759
760 result.frame_header_flags |= ((pic->picture_parameter.pic_info_fields.frame_type ==
761 2 /* INTRA_ONLY_FRAME */) << RDECODE_FRAME_HDR_INFO_AV1_INTRA_ONLY_SHIFT) &
762 RDECODE_FRAME_HDR_INFO_AV1_INTRA_ONLY_MASK;
763
764 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.allow_intrabc
765 << RDECODE_FRAME_HDR_INFO_AV1_ALLOW_INTRABC_SHIFT) &
766 RDECODE_FRAME_HDR_INFO_AV1_ALLOW_INTRABC_MASK;
767
768 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.allow_high_precision_mv
769 << RDECODE_FRAME_HDR_INFO_AV1_ALLOW_HIGH_PRECISION_MV_SHIFT) &
770 RDECODE_FRAME_HDR_INFO_AV1_ALLOW_HIGH_PRECISION_MV_MASK;
771
772 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.mono_chrome
773 << RDECODE_FRAME_HDR_INFO_AV1_MONOCHROME_SHIFT) &
774 RDECODE_FRAME_HDR_INFO_AV1_MONOCHROME_MASK;
775
776 result.frame_header_flags |= (pic->picture_parameter.mode_control_fields.skip_mode_present
777 << RDECODE_FRAME_HDR_INFO_AV1_SKIP_MODE_FLAG_SHIFT) &
778 RDECODE_FRAME_HDR_INFO_AV1_SKIP_MODE_FLAG_MASK;
779
780 result.frame_header_flags |= (((pic->picture_parameter.qmatrix_fields.qm_y == 0xf) ? 0 : 1)
781 << RDECODE_FRAME_HDR_INFO_AV1_USING_QMATRIX_SHIFT) &
782 RDECODE_FRAME_HDR_INFO_AV1_USING_QMATRIX_MASK;
783
784 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.enable_filter_intra
785 << RDECODE_FRAME_HDR_INFO_AV1_ENABLE_FILTER_INTRA_SHIFT) &
786 RDECODE_FRAME_HDR_INFO_AV1_ENABLE_FILTER_INTRA_MASK;
787
788 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.enable_intra_edge_filter
789 << RDECODE_FRAME_HDR_INFO_AV1_ENABLE_INTRA_EDGE_FILTER_SHIFT) &
790 RDECODE_FRAME_HDR_INFO_AV1_ENABLE_INTRA_EDGE_FILTER_MASK;
791
792 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.enable_interintra_compound
793 << RDECODE_FRAME_HDR_INFO_AV1_ENABLE_INTERINTRA_COMPOUND_SHIFT) &
794 RDECODE_FRAME_HDR_INFO_AV1_ENABLE_INTERINTRA_COMPOUND_MASK;
795
796 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.enable_masked_compound
797 << RDECODE_FRAME_HDR_INFO_AV1_ENABLE_MASKED_COMPOUND_SHIFT) &
798 RDECODE_FRAME_HDR_INFO_AV1_ENABLE_MASKED_COMPOUND_MASK;
799
800 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.allow_warped_motion
801 << RDECODE_FRAME_HDR_INFO_AV1_ALLOW_WARPED_MOTION_SHIFT) &
802 RDECODE_FRAME_HDR_INFO_AV1_ALLOW_WARPED_MOTION_MASK;
803
804 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.enable_dual_filter
805 << RDECODE_FRAME_HDR_INFO_AV1_ENABLE_DUAL_FILTER_SHIFT) &
806 RDECODE_FRAME_HDR_INFO_AV1_ENABLE_DUAL_FILTER_MASK;
807
808 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.enable_order_hint
809 << RDECODE_FRAME_HDR_INFO_AV1_ENABLE_ORDER_HINT_SHIFT) &
810 RDECODE_FRAME_HDR_INFO_AV1_ENABLE_ORDER_HINT_MASK;
811
812 result.frame_header_flags |= (pic->picture_parameter.seq_info_fields.enable_jnt_comp
813 << RDECODE_FRAME_HDR_INFO_AV1_ENABLE_JNT_COMP_SHIFT) &
814 RDECODE_FRAME_HDR_INFO_AV1_ENABLE_JNT_COMP_MASK;
815
816 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.use_ref_frame_mvs
817 << RDECODE_FRAME_HDR_INFO_AV1_ALLOW_REF_FRAME_MVS_SHIFT) &
818 RDECODE_FRAME_HDR_INFO_AV1_ALLOW_REF_FRAME_MVS_MASK;
819
820 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.allow_screen_content_tools
821 << RDECODE_FRAME_HDR_INFO_AV1_ALLOW_SCREEN_CONTENT_TOOLS_SHIFT) &
822 RDECODE_FRAME_HDR_INFO_AV1_ALLOW_SCREEN_CONTENT_TOOLS_MASK;
823
824 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.force_integer_mv
825 << RDECODE_FRAME_HDR_INFO_AV1_CUR_FRAME_FORCE_INTEGER_MV_SHIFT) &
826 RDECODE_FRAME_HDR_INFO_AV1_CUR_FRAME_FORCE_INTEGER_MV_MASK;
827
828 result.frame_header_flags |= (pic->picture_parameter.loop_filter_info_fields.mode_ref_delta_enabled
829 << RDECODE_FRAME_HDR_INFO_AV1_MODE_REF_DELTA_ENABLED_SHIFT) &
830 RDECODE_FRAME_HDR_INFO_AV1_MODE_REF_DELTA_ENABLED_MASK;
831
832 result.frame_header_flags |= (pic->picture_parameter.loop_filter_info_fields.mode_ref_delta_update
833 << RDECODE_FRAME_HDR_INFO_AV1_MODE_REF_DELTA_UPDATE_SHIFT) &
834 RDECODE_FRAME_HDR_INFO_AV1_MODE_REF_DELTA_UPDATE_MASK;
835
836 result.frame_header_flags |= (pic->picture_parameter.mode_control_fields.delta_q_present_flag
837 << RDECODE_FRAME_HDR_INFO_AV1_DELTA_Q_PRESENT_FLAG_SHIFT) &
838 RDECODE_FRAME_HDR_INFO_AV1_DELTA_Q_PRESENT_FLAG_MASK;
839
840 result.frame_header_flags |= (pic->picture_parameter.mode_control_fields.delta_lf_present_flag
841 << RDECODE_FRAME_HDR_INFO_AV1_DELTA_LF_PRESENT_FLAG_SHIFT) &
842 RDECODE_FRAME_HDR_INFO_AV1_DELTA_LF_PRESENT_FLAG_MASK;
843
844 result.frame_header_flags |= (pic->picture_parameter.mode_control_fields.reduced_tx_set_used
845 << RDECODE_FRAME_HDR_INFO_AV1_REDUCED_TX_SET_USED_SHIFT) &
846 RDECODE_FRAME_HDR_INFO_AV1_REDUCED_TX_SET_USED_MASK;
847
848 result.frame_header_flags |= (pic->picture_parameter.seg_info.segment_info_fields.enabled
849 << RDECODE_FRAME_HDR_INFO_AV1_SEGMENTATION_ENABLED_SHIFT) &
850 RDECODE_FRAME_HDR_INFO_AV1_SEGMENTATION_ENABLED_MASK;
851
852 result.frame_header_flags |= (pic->picture_parameter.seg_info.segment_info_fields.update_map
853 << RDECODE_FRAME_HDR_INFO_AV1_SEGMENTATION_UPDATE_MAP_SHIFT) &
854 RDECODE_FRAME_HDR_INFO_AV1_SEGMENTATION_UPDATE_MAP_MASK;
855
856 result.frame_header_flags |= (pic->picture_parameter.seg_info.segment_info_fields.temporal_update
857 << RDECODE_FRAME_HDR_INFO_AV1_SEGMENTATION_TEMPORAL_UPDATE_SHIFT) &
858 RDECODE_FRAME_HDR_INFO_AV1_SEGMENTATION_TEMPORAL_UPDATE_MASK;
859
860 result.frame_header_flags |= (pic->picture_parameter.mode_control_fields.delta_lf_multi
861 << RDECODE_FRAME_HDR_INFO_AV1_DELTA_LF_MULTI_SHIFT) &
862 RDECODE_FRAME_HDR_INFO_AV1_DELTA_LF_MULTI_MASK;
863
864 result.frame_header_flags |= (pic->picture_parameter.pic_info_fields.is_motion_mode_switchable
865 << RDECODE_FRAME_HDR_INFO_AV1_SWITCHABLE_SKIP_MODE_SHIFT) &
866 RDECODE_FRAME_HDR_INFO_AV1_SWITCHABLE_SKIP_MODE_MASK;
867
868 result.frame_header_flags |= ((!pic->picture_parameter.refresh_frame_flags)
869 << RDECODE_FRAME_HDR_INFO_AV1_SKIP_REFERENCE_UPDATE_SHIFT) &
870 RDECODE_FRAME_HDR_INFO_AV1_SKIP_REFERENCE_UPDATE_MASK;
871
872 result.frame_header_flags |= ((!pic->picture_parameter.seq_info_fields.ref_frame_mvs)
873 << RDECODE_FRAME_HDR_INFO_AV1_DISABLE_REF_FRAME_MVS_SHIFT) &
874 RDECODE_FRAME_HDR_INFO_AV1_DISABLE_REF_FRAME_MVS_MASK;
875
876 result.current_frame_id = pic->picture_parameter.current_frame_id;
877 result.frame_offset = pic->picture_parameter.order_hint;
878
879 result.profile = pic->picture_parameter.profile;
880 result.is_annexb = 0;
881 result.frame_type = pic->picture_parameter.pic_info_fields.frame_type;
882 result.primary_ref_frame = pic->picture_parameter.primary_ref_frame;
883 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); ++i) {
884 if (dec->render_pic_list[i] && dec->render_pic_list[i] == target) {
885 result.curr_pic_idx = (uintptr_t)vl_video_buffer_get_associated_data(target, &dec->base);
886 break;
887 } else if (!dec->render_pic_list[i]) {
888 dec->render_pic_list[i] = target;
889 result.curr_pic_idx = dec->ref_idx;
890 vl_video_buffer_set_associated_data(target, &dec->base, (void *)(uintptr_t)dec->ref_idx++,
891 &radeon_dec_destroy_associated_data);
892 break;
893 }
894 }
895
896 result.sb_size = pic->picture_parameter.seq_info_fields.use_128x128_superblock;
897 result.interp_filter = pic->picture_parameter.interp_filter;
898 for (i = 0; i < 2; ++i)
899 result.filter_level[i] = pic->picture_parameter.filter_level[i];
900 result.filter_level_u = pic->picture_parameter.filter_level_u;
901 result.filter_level_v = pic->picture_parameter.filter_level_v;
902 result.sharpness_level = pic->picture_parameter.loop_filter_info_fields.sharpness_level;
903 for (i = 0; i < 8; ++i)
904 result.ref_deltas[i] = pic->picture_parameter.ref_deltas[i];
905 for (i = 0; i < 2; ++i)
906 result.mode_deltas[i] = pic->picture_parameter.mode_deltas[i];
907 result.base_qindex = pic->picture_parameter.base_qindex;
908 result.y_dc_delta_q = pic->picture_parameter.y_dc_delta_q;
909 result.u_dc_delta_q = pic->picture_parameter.u_dc_delta_q;
910 result.v_dc_delta_q = pic->picture_parameter.v_dc_delta_q;
911 result.u_ac_delta_q = pic->picture_parameter.u_ac_delta_q;
912 result.v_ac_delta_q = pic->picture_parameter.v_ac_delta_q;
913 result.qm_y = pic->picture_parameter.qmatrix_fields.qm_y | 0xf0;
914 result.qm_u = pic->picture_parameter.qmatrix_fields.qm_u | 0xf0;
915 result.qm_v = pic->picture_parameter.qmatrix_fields.qm_v | 0xf0;
916 result.delta_q_res = 1 << pic->picture_parameter.mode_control_fields.log2_delta_q_res;
917 result.delta_lf_res = 1 << pic->picture_parameter.mode_control_fields.log2_delta_lf_res;
918
919 result.tile_cols = pic->picture_parameter.tile_cols;
920 result.tile_rows = pic->picture_parameter.tile_rows;
921 result.tx_mode = pic->picture_parameter.mode_control_fields.tx_mode;
922 result.reference_mode = (pic->picture_parameter.mode_control_fields.reference_select == 1) ? 2 : 0;
923 result.chroma_format = pic->picture_parameter.seq_info_fields.mono_chrome ? 0 : 1;
924 result.tile_size_bytes = 0xff;
925 result.context_update_tile_id = pic->picture_parameter.context_update_tile_id;
926 for (i = 0; i < 65; ++i) {
927 result.tile_col_start_sb[i] = pic->picture_parameter.tile_col_start_sb[i];
928 result.tile_row_start_sb[i] = pic->picture_parameter.tile_row_start_sb[i];
929 }
930 result.max_width = pic->picture_parameter.max_width;
931 result.max_height = pic->picture_parameter.max_height;
932 if (pic->picture_parameter.pic_info_fields.use_superres) {
933 result.width = (pic->picture_parameter.frame_width * 8 + pic->picture_parameter.superres_scale_denominator / 2) /
934 pic->picture_parameter.superres_scale_denominator;
935 result.superres_scale_denominator = pic->picture_parameter.superres_scale_denominator;
936 } else {
937 result.width = pic->picture_parameter.frame_width;
938 result.superres_scale_denominator = pic->picture_parameter.superres_scale_denominator;
939 }
940 result.height = pic->picture_parameter.frame_height;
941 result.superres_upscaled_width = pic->picture_parameter.frame_width;
942 result.order_hint_bits = pic->picture_parameter.order_hint_bits_minus_1 + 1;
943
944 for (i = 0; i < NUM_AV1_REFS; ++i) {
945 result.ref_frame_map[i] =
946 (pic->ref[i]) ? (uintptr_t)vl_video_buffer_get_associated_data(pic->ref[i], &dec->base)
947 : 0x7f;
948 }
949 for (i = 0; i < NUM_AV1_REFS_PER_FRAME; ++i)
950 result.frame_refs[i] = result.ref_frame_map[pic->picture_parameter.ref_frame_idx[i]];
951
952 result.bit_depth_luma_minus8 = result.bit_depth_chroma_minus8 = pic->picture_parameter.bit_depth_idx << 1;
953
954 for (i = 0; i < 8; ++i) {
955 for (j = 0; j < 8; ++j)
956 result.feature_data[i][j] = pic->picture_parameter.seg_info.feature_data[i][j];
957 result.feature_mask[i] = pic->picture_parameter.seg_info.feature_mask[i];
958 }
959 memcpy(dec->probs, &pic->picture_parameter.seg_info.feature_data, 128);
960 memcpy((dec->probs + 128), &pic->picture_parameter.seg_info.feature_mask, 8);
961
962 result.cdef_damping = pic->picture_parameter.cdef_damping_minus_3 + 3;
963 result.cdef_bits = pic->picture_parameter.cdef_bits;
964 for (i = 0; i < 8; ++i) {
965 result.cdef_strengths[i] = pic->picture_parameter.cdef_y_strengths[i];
966 result.cdef_uv_strengths[i] = pic->picture_parameter.cdef_uv_strengths[i];
967 }
968 result.frame_restoration_type[0] = pic->picture_parameter.loop_restoration_fields.yframe_restoration_type;
969 result.frame_restoration_type[1] = pic->picture_parameter.loop_restoration_fields.cbframe_restoration_type;
970 result.frame_restoration_type[2] = pic->picture_parameter.loop_restoration_fields.crframe_restoration_type;
971 for (i = 0; i < 3; ++i) {
972 int log2_num = 0;
973 int unit_size = pic->picture_parameter.lr_unit_size[i];
974 if (unit_size) {
975 while (unit_size >>= 1)
976 log2_num++;
977 result.log2_restoration_unit_size_minus5[i] = log2_num - 5;
978 } else {
979 result.log2_restoration_unit_size_minus5[i] = 0;
980 }
981 }
982
983 if (pic->picture_parameter.bit_depth_idx) {
984 if (target->buffer_format == PIPE_FORMAT_P010 || target->buffer_format == PIPE_FORMAT_P016) {
985 result.p010_mode = 1;
986 result.msb_mode = 1;
987 } else {
988 result.luma_10to8 = 1;
989 result.chroma_10to8 = 1;
990 }
991 }
992
993 result.preskip_segid = 0;
994 result.last_active_segid = 0;
995 for (i = 0; i < 8; i++) {
996 for (j = 0; j < 8; j++) {
997 if (pic->picture_parameter.seg_info.feature_mask[i] & (1 << j)) {
998 result.last_active_segid = i;
999 if (j >= 5)
1000 result.preskip_segid = 1;
1001 }
1002 }
1003 }
1004
1005 result.seg_lossless_flag = 0;
1006 for (i = 0; i < 8; ++i) {
1007 int av1_get_qindex, qindex;
1008 int segfeature_active = pic->picture_parameter.seg_info.feature_mask[i] & (1 << 0);
1009 if (segfeature_active) {
1010 int seg_qindex = pic->picture_parameter.base_qindex +
1011 pic->picture_parameter.seg_info.feature_data[i][0];
1012 av1_get_qindex = seg_qindex < 0 ? 0 : (seg_qindex > 255 ? 255 : seg_qindex);
1013 } else {
1014 av1_get_qindex = pic->picture_parameter.base_qindex;
1015 }
1016 qindex = pic->picture_parameter.seg_info.segment_info_fields.enabled ?
1017 av1_get_qindex :
1018 pic->picture_parameter.base_qindex;
1019 result.seg_lossless_flag |= (((qindex == 0) && result.y_dc_delta_q == 0 &&
1020 result.u_dc_delta_q == 0 && result.v_dc_delta_q == 0 &&
1021 result.u_ac_delta_q == 0 && result.v_ac_delta_q == 0) << i);
1022 }
1023
1024 rvcn_dec_film_grain_params_t* fg_params = &result.film_grain;
1025 fg_params->apply_grain = pic->picture_parameter.film_grain_info.film_grain_info_fields.apply_grain;
1026 if (fg_params->apply_grain) {
1027 fg_params->random_seed = pic->picture_parameter.film_grain_info.grain_seed;
1028 fg_params->grain_scale_shift =
1029 pic->picture_parameter.film_grain_info.film_grain_info_fields.grain_scale_shift;
1030 fg_params->scaling_shift =
1031 pic->picture_parameter.film_grain_info.film_grain_info_fields.grain_scaling_minus_8 + 8;
1032 fg_params->chroma_scaling_from_luma =
1033 pic->picture_parameter.film_grain_info.film_grain_info_fields.chroma_scaling_from_luma;
1034 fg_params->num_y_points = pic->picture_parameter.film_grain_info.num_y_points;
1035 fg_params->num_cb_points = pic->picture_parameter.film_grain_info.num_cb_points;
1036 fg_params->num_cr_points = pic->picture_parameter.film_grain_info.num_cr_points;
1037 fg_params->cb_mult = pic->picture_parameter.film_grain_info.cb_mult;
1038 fg_params->cb_luma_mult = pic->picture_parameter.film_grain_info.cb_luma_mult;
1039 fg_params->cb_offset = pic->picture_parameter.film_grain_info.cb_offset;
1040 fg_params->cr_mult = pic->picture_parameter.film_grain_info.cr_mult;
1041 fg_params->cr_luma_mult = pic->picture_parameter.film_grain_info.cr_luma_mult;
1042 fg_params->cr_offset = pic->picture_parameter.film_grain_info.cr_offset;
1043 fg_params->bit_depth_minus_8 = pic->picture_parameter.bit_depth_idx << 1;
1044
1045 for (i = 0; i < fg_params->num_y_points; ++i) {
1046 fg_params->scaling_points_y[i][0] = pic->picture_parameter.film_grain_info.point_y_value[i];
1047 fg_params->scaling_points_y[i][1] = pic->picture_parameter.film_grain_info.point_y_scaling[i];
1048 }
1049 for (i = 0; i < fg_params->num_cb_points; ++i) {
1050 fg_params->scaling_points_cb[i][0] = pic->picture_parameter.film_grain_info.point_cb_value[i];
1051 fg_params->scaling_points_cb[i][1] = pic->picture_parameter.film_grain_info.point_cb_scaling[i];
1052 }
1053 for (i = 0; i < fg_params->num_cr_points; ++i) {
1054 fg_params->scaling_points_cr[i][0] = pic->picture_parameter.film_grain_info.point_cr_value[i];
1055 fg_params->scaling_points_cr[i][1] = pic->picture_parameter.film_grain_info.point_cr_scaling[i];
1056 }
1057
1058 fg_params->ar_coeff_lag = pic->picture_parameter.film_grain_info.film_grain_info_fields.ar_coeff_lag;
1059 fg_params->ar_coeff_shift =
1060 pic->picture_parameter.film_grain_info.film_grain_info_fields.ar_coeff_shift_minus_6 + 6;
1061
1062 for (i = 0; i < 24; ++i)
1063 fg_params->ar_coeffs_y[i] = pic->picture_parameter.film_grain_info.ar_coeffs_y[i];
1064
1065 for (i = 0; i < 25; ++i) {
1066 fg_params->ar_coeffs_cb[i] = pic->picture_parameter.film_grain_info.ar_coeffs_cb[i];
1067 fg_params->ar_coeffs_cr[i] = pic->picture_parameter.film_grain_info.ar_coeffs_cr[i];
1068 }
1069
1070 fg_params->overlap_flag = pic->picture_parameter.film_grain_info.film_grain_info_fields.overlap_flag;
1071 fg_params->clip_to_restricted_range =
1072 pic->picture_parameter.film_grain_info.film_grain_info_fields.clip_to_restricted_range;
1073 }
1074
1075 result.uncompressed_header_size = 0;
1076 for (i = 0; i < 7; ++i) {
1077 result.global_motion[i + 1].wmtype = (rvcn_dec_transformation_type_e)pic->picture_parameter.wm[i].wmtype;
1078 for (j = 0; j < 6; ++j)
1079 result.global_motion[i + 1].wmmat[j] = pic->picture_parameter.wm[i].wmmat[j];
1080 }
1081 for (i = 0; i < 256; ++i) {
1082 result.tile_info[i].offset = pic->slice_parameter.slice_data_offset[i];
1083 result.tile_info[i].size = pic->slice_parameter.slice_data_size[i];
1084 }
1085
1086 if (dec->dpb_type == DPB_DYNAMIC_TIER_2) {
1087 dec->ref_codec.bts = pic->picture_parameter.bit_depth_idx ? CODEC_10_BITS : CODEC_8_BITS;
1088 dec->ref_codec.index = result.curr_pic_idx;
1089 dec->ref_codec.ref_size = 8;
1090 memset(dec->ref_codec.ref_list, 0x7f, sizeof(dec->ref_codec.ref_list));
1091 memcpy(dec->ref_codec.ref_list, result.ref_frame_map, sizeof(result.ref_frame_map));
1092 }
1093
1094 return result;
1095 }
1096
rvcn_init_mode_probs(void *prob)1097 static void rvcn_init_mode_probs(void *prob)
1098 {
1099 rvcn_av1_frame_context_t * fc = (rvcn_av1_frame_context_t*)prob;
1100 int i;
1101
1102 memcpy(fc->palette_y_size_cdf, default_palette_y_size_cdf, sizeof(default_palette_y_size_cdf));
1103 memcpy(fc->palette_uv_size_cdf, default_palette_uv_size_cdf, sizeof(default_palette_uv_size_cdf));
1104 memcpy(fc->palette_y_color_index_cdf, default_palette_y_color_index_cdf, sizeof(default_palette_y_color_index_cdf));
1105 memcpy(fc->palette_uv_color_index_cdf, default_palette_uv_color_index_cdf, sizeof(default_palette_uv_color_index_cdf));
1106 memcpy(fc->kf_y_cdf, default_kf_y_mode_cdf, sizeof(default_kf_y_mode_cdf));
1107 memcpy(fc->angle_delta_cdf, default_angle_delta_cdf, sizeof(default_angle_delta_cdf));
1108 memcpy(fc->comp_inter_cdf, default_comp_inter_cdf, sizeof(default_comp_inter_cdf));
1109 memcpy(fc->comp_ref_type_cdf, default_comp_ref_type_cdf,sizeof(default_comp_ref_type_cdf));
1110 memcpy(fc->uni_comp_ref_cdf, default_uni_comp_ref_cdf, sizeof(default_uni_comp_ref_cdf));
1111 memcpy(fc->palette_y_mode_cdf, default_palette_y_mode_cdf, sizeof(default_palette_y_mode_cdf));
1112 memcpy(fc->palette_uv_mode_cdf, default_palette_uv_mode_cdf, sizeof(default_palette_uv_mode_cdf));
1113 memcpy(fc->comp_ref_cdf, default_comp_ref_cdf, sizeof(default_comp_ref_cdf));
1114 memcpy(fc->comp_bwdref_cdf, default_comp_bwdref_cdf, sizeof(default_comp_bwdref_cdf));
1115 memcpy(fc->single_ref_cdf, default_single_ref_cdf, sizeof(default_single_ref_cdf));
1116 memcpy(fc->txfm_partition_cdf, default_txfm_partition_cdf, sizeof(default_txfm_partition_cdf));
1117 memcpy(fc->compound_index_cdf, default_compound_idx_cdfs, sizeof(default_compound_idx_cdfs));
1118 memcpy(fc->comp_group_idx_cdf, default_comp_group_idx_cdfs, sizeof(default_comp_group_idx_cdfs));
1119 memcpy(fc->newmv_cdf, default_newmv_cdf, sizeof(default_newmv_cdf));
1120 memcpy(fc->zeromv_cdf, default_zeromv_cdf, sizeof(default_zeromv_cdf));
1121 memcpy(fc->refmv_cdf, default_refmv_cdf, sizeof(default_refmv_cdf));
1122 memcpy(fc->drl_cdf, default_drl_cdf, sizeof(default_drl_cdf));
1123 memcpy(fc->motion_mode_cdf, default_motion_mode_cdf, sizeof(default_motion_mode_cdf));
1124 memcpy(fc->obmc_cdf, default_obmc_cdf, sizeof(default_obmc_cdf));
1125 memcpy(fc->inter_compound_mode_cdf, default_inter_compound_mode_cdf, sizeof(default_inter_compound_mode_cdf));
1126 memcpy(fc->compound_type_cdf, default_compound_type_cdf, sizeof(default_compound_type_cdf));
1127 memcpy(fc->wedge_idx_cdf, default_wedge_idx_cdf, sizeof(default_wedge_idx_cdf));
1128 memcpy(fc->interintra_cdf, default_interintra_cdf, sizeof(default_interintra_cdf));
1129 memcpy(fc->wedge_interintra_cdf, default_wedge_interintra_cdf, sizeof(default_wedge_interintra_cdf));
1130 memcpy(fc->interintra_mode_cdf, default_interintra_mode_cdf, sizeof(default_interintra_mode_cdf));
1131 memcpy(fc->pred_cdf, default_segment_pred_cdf, sizeof(default_segment_pred_cdf));
1132 memcpy(fc->switchable_restore_cdf, default_switchable_restore_cdf, sizeof(default_switchable_restore_cdf));
1133 memcpy(fc->wiener_restore_cdf, default_wiener_restore_cdf, sizeof(default_wiener_restore_cdf));
1134 memcpy(fc->sgrproj_restore_cdf, default_sgrproj_restore_cdf, sizeof(default_sgrproj_restore_cdf));
1135 memcpy(fc->y_mode_cdf, default_if_y_mode_cdf, sizeof(default_if_y_mode_cdf));
1136 memcpy(fc->uv_mode_cdf, default_uv_mode_cdf, sizeof(default_uv_mode_cdf));
1137 memcpy(fc->switchable_interp_cdf, default_switchable_interp_cdf, sizeof(default_switchable_interp_cdf));
1138 memcpy(fc->partition_cdf, default_partition_cdf, sizeof(default_partition_cdf));
1139 memcpy(fc->intra_ext_tx_cdf, default_intra_ext_tx_cdf, sizeof(default_intra_ext_tx_cdf));
1140 memcpy(fc->inter_ext_tx_cdf, default_inter_ext_tx_cdf, sizeof(default_inter_ext_tx_cdf));
1141 memcpy(fc->skip_cdfs, default_skip_cdfs, sizeof(default_skip_cdfs));
1142 memcpy(fc->intra_inter_cdf, default_intra_inter_cdf, sizeof(default_intra_inter_cdf));
1143 memcpy(fc->tree_cdf, default_seg_tree_cdf, sizeof(default_seg_tree_cdf));
1144 for (i = 0; i < SPATIAL_PREDICTION_PROBS; ++i)
1145 memcpy(fc->spatial_pred_seg_cdf[i], default_spatial_pred_seg_tree_cdf[i], sizeof(default_spatial_pred_seg_tree_cdf[i]));
1146 memcpy(fc->tx_size_cdf, default_tx_size_cdf, sizeof(default_tx_size_cdf));
1147 memcpy(fc->delta_q_cdf, default_delta_q_cdf, sizeof(default_delta_q_cdf));
1148 memcpy(fc->skip_mode_cdfs, default_skip_mode_cdfs, sizeof(default_skip_mode_cdfs));
1149 memcpy(fc->delta_lf_cdf, default_delta_lf_cdf, sizeof(default_delta_lf_cdf));
1150 memcpy(fc->delta_lf_multi_cdf, default_delta_lf_multi_cdf, sizeof(default_delta_lf_multi_cdf));
1151 memcpy(fc->cfl_sign_cdf, default_cfl_sign_cdf, sizeof(default_cfl_sign_cdf));
1152 memcpy(fc->cfl_alpha_cdf, default_cfl_alpha_cdf, sizeof(default_cfl_alpha_cdf));
1153 memcpy(fc->filter_intra_cdfs, default_filter_intra_cdfs, sizeof(default_filter_intra_cdfs));
1154 memcpy(fc->filter_intra_mode_cdf, default_filter_intra_mode_cdf, sizeof(default_filter_intra_mode_cdf));
1155 memcpy(fc->intrabc_cdf, default_intrabc_cdf, sizeof(default_intrabc_cdf));
1156 }
1157
rvcn_vcn4_init_mode_probs(void *prob)1158 static void rvcn_vcn4_init_mode_probs(void *prob)
1159 {
1160 rvcn_av1_vcn4_frame_context_t * fc = (rvcn_av1_vcn4_frame_context_t*)prob;
1161 int i;
1162
1163 memcpy(fc->palette_y_size_cdf, default_palette_y_size_cdf, sizeof(default_palette_y_size_cdf));
1164 memcpy(fc->palette_uv_size_cdf, default_palette_uv_size_cdf, sizeof(default_palette_uv_size_cdf));
1165 memcpy(fc->palette_y_color_index_cdf, default_palette_y_color_index_cdf, sizeof(default_palette_y_color_index_cdf));
1166 memcpy(fc->palette_uv_color_index_cdf, default_palette_uv_color_index_cdf, sizeof(default_palette_uv_color_index_cdf));
1167 memcpy(fc->kf_y_cdf, default_kf_y_mode_cdf, sizeof(default_kf_y_mode_cdf));
1168 memcpy(fc->angle_delta_cdf, default_angle_delta_cdf, sizeof(default_angle_delta_cdf));
1169 memcpy(fc->comp_inter_cdf, default_comp_inter_cdf, sizeof(default_comp_inter_cdf));
1170 memcpy(fc->comp_ref_type_cdf, default_comp_ref_type_cdf,sizeof(default_comp_ref_type_cdf));
1171 memcpy(fc->uni_comp_ref_cdf, default_uni_comp_ref_cdf, sizeof(default_uni_comp_ref_cdf));
1172 memcpy(fc->palette_y_mode_cdf, default_palette_y_mode_cdf, sizeof(default_palette_y_mode_cdf));
1173 memcpy(fc->palette_uv_mode_cdf, default_palette_uv_mode_cdf, sizeof(default_palette_uv_mode_cdf));
1174 memcpy(fc->comp_ref_cdf, default_comp_ref_cdf, sizeof(default_comp_ref_cdf));
1175 memcpy(fc->comp_bwdref_cdf, default_comp_bwdref_cdf, sizeof(default_comp_bwdref_cdf));
1176 memcpy(fc->single_ref_cdf, default_single_ref_cdf, sizeof(default_single_ref_cdf));
1177 memcpy(fc->txfm_partition_cdf, default_txfm_partition_cdf, sizeof(default_txfm_partition_cdf));
1178 memcpy(fc->compound_index_cdf, default_compound_idx_cdfs, sizeof(default_compound_idx_cdfs));
1179 memcpy(fc->comp_group_idx_cdf, default_comp_group_idx_cdfs, sizeof(default_comp_group_idx_cdfs));
1180 memcpy(fc->newmv_cdf, default_newmv_cdf, sizeof(default_newmv_cdf));
1181 memcpy(fc->zeromv_cdf, default_zeromv_cdf, sizeof(default_zeromv_cdf));
1182 memcpy(fc->refmv_cdf, default_refmv_cdf, sizeof(default_refmv_cdf));
1183 memcpy(fc->drl_cdf, default_drl_cdf, sizeof(default_drl_cdf));
1184 memcpy(fc->motion_mode_cdf, default_motion_mode_cdf, sizeof(default_motion_mode_cdf));
1185 memcpy(fc->obmc_cdf, default_obmc_cdf, sizeof(default_obmc_cdf));
1186 memcpy(fc->inter_compound_mode_cdf, default_inter_compound_mode_cdf, sizeof(default_inter_compound_mode_cdf));
1187 memcpy(fc->compound_type_cdf, default_compound_type_cdf, sizeof(default_compound_type_cdf));
1188 memcpy(fc->wedge_idx_cdf, default_wedge_idx_cdf, sizeof(default_wedge_idx_cdf));
1189 memcpy(fc->interintra_cdf, default_interintra_cdf, sizeof(default_interintra_cdf));
1190 memcpy(fc->wedge_interintra_cdf, default_wedge_interintra_cdf, sizeof(default_wedge_interintra_cdf));
1191 memcpy(fc->interintra_mode_cdf, default_interintra_mode_cdf, sizeof(default_interintra_mode_cdf));
1192 memcpy(fc->pred_cdf, default_segment_pred_cdf, sizeof(default_segment_pred_cdf));
1193 memcpy(fc->switchable_restore_cdf, default_switchable_restore_cdf, sizeof(default_switchable_restore_cdf));
1194 memcpy(fc->wiener_restore_cdf, default_wiener_restore_cdf, sizeof(default_wiener_restore_cdf));
1195 memcpy(fc->sgrproj_restore_cdf, default_sgrproj_restore_cdf, sizeof(default_sgrproj_restore_cdf));
1196 memcpy(fc->y_mode_cdf, default_if_y_mode_cdf, sizeof(default_if_y_mode_cdf));
1197 memcpy(fc->uv_mode_cdf, default_uv_mode_cdf, sizeof(default_uv_mode_cdf));
1198 memcpy(fc->switchable_interp_cdf, default_switchable_interp_cdf, sizeof(default_switchable_interp_cdf));
1199 memcpy(fc->partition_cdf, default_partition_cdf, sizeof(default_partition_cdf));
1200 memcpy(fc->intra_ext_tx_cdf, &default_intra_ext_tx_cdf[1], sizeof(default_intra_ext_tx_cdf[1]) * 2);
1201 memcpy(fc->inter_ext_tx_cdf, &default_inter_ext_tx_cdf[1], sizeof(default_inter_ext_tx_cdf[1]) * 3);
1202 memcpy(fc->skip_cdfs, default_skip_cdfs, sizeof(default_skip_cdfs));
1203 memcpy(fc->intra_inter_cdf, default_intra_inter_cdf, sizeof(default_intra_inter_cdf));
1204 memcpy(fc->tree_cdf, default_seg_tree_cdf, sizeof(default_seg_tree_cdf));
1205 for (i = 0; i < SPATIAL_PREDICTION_PROBS; ++i)
1206 memcpy(fc->spatial_pred_seg_cdf[i], default_spatial_pred_seg_tree_cdf[i], sizeof(default_spatial_pred_seg_tree_cdf[i]));
1207 memcpy(fc->tx_size_cdf, default_tx_size_cdf, sizeof(default_tx_size_cdf));
1208 memcpy(fc->delta_q_cdf, default_delta_q_cdf, sizeof(default_delta_q_cdf));
1209 memcpy(fc->skip_mode_cdfs, default_skip_mode_cdfs, sizeof(default_skip_mode_cdfs));
1210 memcpy(fc->delta_lf_cdf, default_delta_lf_cdf, sizeof(default_delta_lf_cdf));
1211 memcpy(fc->delta_lf_multi_cdf, default_delta_lf_multi_cdf, sizeof(default_delta_lf_multi_cdf));
1212 memcpy(fc->cfl_sign_cdf, default_cfl_sign_cdf, sizeof(default_cfl_sign_cdf));
1213 memcpy(fc->cfl_alpha_cdf, default_cfl_alpha_cdf, sizeof(default_cfl_alpha_cdf));
1214 memcpy(fc->filter_intra_cdfs, default_filter_intra_cdfs, sizeof(default_filter_intra_cdfs));
1215 memcpy(fc->filter_intra_mode_cdf, default_filter_intra_mode_cdf, sizeof(default_filter_intra_mode_cdf));
1216 memcpy(fc->intrabc_cdf, default_intrabc_cdf, sizeof(default_intrabc_cdf));
1217 }
1218
rvcn_av1_init_mv_probs(void *prob)1219 static void rvcn_av1_init_mv_probs(void *prob)
1220 {
1221 rvcn_av1_frame_context_t * fc = (rvcn_av1_frame_context_t*)prob;
1222
1223 memcpy(fc->nmvc_joints_cdf, default_nmv_context.joints_cdf, sizeof(default_nmv_context.joints_cdf));
1224 memcpy(fc->nmvc_0_bits_cdf, default_nmv_context.comps[0].bits_cdf, sizeof(default_nmv_context.comps[0].bits_cdf));
1225 memcpy(fc->nmvc_0_class0_cdf, default_nmv_context.comps[0].class0_cdf, sizeof(default_nmv_context.comps[0].class0_cdf));
1226 memcpy(fc->nmvc_0_class0_fp_cdf, default_nmv_context.comps[0].class0_fp_cdf, sizeof(default_nmv_context.comps[0].class0_fp_cdf));
1227 memcpy(fc->nmvc_0_class0_hp_cdf, default_nmv_context.comps[0].class0_hp_cdf, sizeof(default_nmv_context.comps[0].class0_hp_cdf));
1228 memcpy(fc->nmvc_0_classes_cdf, default_nmv_context.comps[0].classes_cdf, sizeof(default_nmv_context.comps[0].classes_cdf));
1229 memcpy(fc->nmvc_0_fp_cdf, default_nmv_context.comps[0].fp_cdf, sizeof(default_nmv_context.comps[0].fp_cdf));
1230 memcpy(fc->nmvc_0_hp_cdf, default_nmv_context.comps[0].hp_cdf, sizeof(default_nmv_context.comps[0].hp_cdf));
1231 memcpy(fc->nmvc_0_sign_cdf, default_nmv_context.comps[0].sign_cdf, sizeof(default_nmv_context.comps[0].sign_cdf));
1232 memcpy(fc->nmvc_1_bits_cdf, default_nmv_context.comps[1].bits_cdf, sizeof(default_nmv_context.comps[1].bits_cdf));
1233 memcpy(fc->nmvc_1_class0_cdf, default_nmv_context.comps[1].class0_cdf, sizeof(default_nmv_context.comps[1].class0_cdf));
1234 memcpy(fc->nmvc_1_class0_fp_cdf, default_nmv_context.comps[1].class0_fp_cdf, sizeof(default_nmv_context.comps[1].class0_fp_cdf));
1235 memcpy(fc->nmvc_1_class0_hp_cdf, default_nmv_context.comps[1].class0_hp_cdf, sizeof(default_nmv_context.comps[1].class0_hp_cdf));
1236 memcpy(fc->nmvc_1_classes_cdf, default_nmv_context.comps[1].classes_cdf, sizeof(default_nmv_context.comps[1].classes_cdf));
1237 memcpy(fc->nmvc_1_fp_cdf, default_nmv_context.comps[1].fp_cdf, sizeof(default_nmv_context.comps[1].fp_cdf));
1238 memcpy(fc->nmvc_1_hp_cdf, default_nmv_context.comps[1].hp_cdf, sizeof(default_nmv_context.comps[1].hp_cdf));
1239 memcpy(fc->nmvc_1_sign_cdf, default_nmv_context.comps[1].sign_cdf, sizeof(default_nmv_context.comps[1].sign_cdf));
1240 memcpy(fc->ndvc_joints_cdf, default_nmv_context.joints_cdf, sizeof(default_nmv_context.joints_cdf));
1241 memcpy(fc->ndvc_0_bits_cdf, default_nmv_context.comps[0].bits_cdf, sizeof(default_nmv_context.comps[0].bits_cdf));
1242 memcpy(fc->ndvc_0_class0_cdf, default_nmv_context.comps[0].class0_cdf, sizeof(default_nmv_context.comps[0].class0_cdf));
1243 memcpy(fc->ndvc_0_class0_fp_cdf, default_nmv_context.comps[0].class0_fp_cdf, sizeof(default_nmv_context.comps[0].class0_fp_cdf));
1244 memcpy(fc->ndvc_0_class0_hp_cdf, default_nmv_context.comps[0].class0_hp_cdf, sizeof(default_nmv_context.comps[0].class0_hp_cdf));
1245 memcpy(fc->ndvc_0_classes_cdf, default_nmv_context.comps[0].classes_cdf, sizeof(default_nmv_context.comps[0].classes_cdf));
1246 memcpy(fc->ndvc_0_fp_cdf, default_nmv_context.comps[0].fp_cdf, sizeof(default_nmv_context.comps[0].fp_cdf));
1247 memcpy(fc->ndvc_0_hp_cdf, default_nmv_context.comps[0].hp_cdf, sizeof(default_nmv_context.comps[0].hp_cdf));
1248 memcpy(fc->ndvc_0_sign_cdf, default_nmv_context.comps[0].sign_cdf, sizeof(default_nmv_context.comps[0].sign_cdf));
1249 memcpy(fc->ndvc_1_bits_cdf, default_nmv_context.comps[1].bits_cdf, sizeof(default_nmv_context.comps[1].bits_cdf));
1250 memcpy(fc->ndvc_1_class0_cdf, default_nmv_context.comps[1].class0_cdf, sizeof(default_nmv_context.comps[1].class0_cdf));
1251 memcpy(fc->ndvc_1_class0_fp_cdf, default_nmv_context.comps[1].class0_fp_cdf, sizeof(default_nmv_context.comps[1].class0_fp_cdf));
1252 memcpy(fc->ndvc_1_class0_hp_cdf, default_nmv_context.comps[1].class0_hp_cdf, sizeof(default_nmv_context.comps[1].class0_hp_cdf));
1253 memcpy(fc->ndvc_1_classes_cdf, default_nmv_context.comps[1].classes_cdf, sizeof(default_nmv_context.comps[1].classes_cdf));
1254 memcpy(fc->ndvc_1_fp_cdf, default_nmv_context.comps[1].fp_cdf, sizeof(default_nmv_context.comps[1].fp_cdf));
1255 memcpy(fc->ndvc_1_hp_cdf, default_nmv_context.comps[1].hp_cdf, sizeof(default_nmv_context.comps[1].hp_cdf));
1256 memcpy(fc->ndvc_1_sign_cdf, default_nmv_context.comps[1].sign_cdf, sizeof(default_nmv_context.comps[1].sign_cdf));
1257 }
1258
rvcn_vcn4_av1_init_mv_probs(void *prob)1259 static void rvcn_vcn4_av1_init_mv_probs(void *prob)
1260 {
1261 rvcn_av1_vcn4_frame_context_t * fc = (rvcn_av1_vcn4_frame_context_t*)prob;
1262
1263 memcpy(fc->nmvc_joints_cdf, default_nmv_context.joints_cdf, sizeof(default_nmv_context.joints_cdf));
1264 memcpy(fc->nmvc_0_bits_cdf, default_nmv_context.comps[0].bits_cdf, sizeof(default_nmv_context.comps[0].bits_cdf));
1265 memcpy(fc->nmvc_0_class0_cdf, default_nmv_context.comps[0].class0_cdf, sizeof(default_nmv_context.comps[0].class0_cdf));
1266 memcpy(fc->nmvc_0_class0_fp_cdf, default_nmv_context.comps[0].class0_fp_cdf, sizeof(default_nmv_context.comps[0].class0_fp_cdf));
1267 memcpy(fc->nmvc_0_class0_hp_cdf, default_nmv_context.comps[0].class0_hp_cdf, sizeof(default_nmv_context.comps[0].class0_hp_cdf));
1268 memcpy(fc->nmvc_0_classes_cdf, default_nmv_context.comps[0].classes_cdf, sizeof(default_nmv_context.comps[0].classes_cdf));
1269 memcpy(fc->nmvc_0_fp_cdf, default_nmv_context.comps[0].fp_cdf, sizeof(default_nmv_context.comps[0].fp_cdf));
1270 memcpy(fc->nmvc_0_hp_cdf, default_nmv_context.comps[0].hp_cdf, sizeof(default_nmv_context.comps[0].hp_cdf));
1271 memcpy(fc->nmvc_0_sign_cdf, default_nmv_context.comps[0].sign_cdf, sizeof(default_nmv_context.comps[0].sign_cdf));
1272 memcpy(fc->nmvc_1_bits_cdf, default_nmv_context.comps[1].bits_cdf, sizeof(default_nmv_context.comps[1].bits_cdf));
1273 memcpy(fc->nmvc_1_class0_cdf, default_nmv_context.comps[1].class0_cdf, sizeof(default_nmv_context.comps[1].class0_cdf));
1274 memcpy(fc->nmvc_1_class0_fp_cdf, default_nmv_context.comps[1].class0_fp_cdf, sizeof(default_nmv_context.comps[1].class0_fp_cdf));
1275 memcpy(fc->nmvc_1_class0_hp_cdf, default_nmv_context.comps[1].class0_hp_cdf, sizeof(default_nmv_context.comps[1].class0_hp_cdf));
1276 memcpy(fc->nmvc_1_classes_cdf, default_nmv_context.comps[1].classes_cdf, sizeof(default_nmv_context.comps[1].classes_cdf));
1277 memcpy(fc->nmvc_1_fp_cdf, default_nmv_context.comps[1].fp_cdf, sizeof(default_nmv_context.comps[1].fp_cdf));
1278 memcpy(fc->nmvc_1_hp_cdf, default_nmv_context.comps[1].hp_cdf, sizeof(default_nmv_context.comps[1].hp_cdf));
1279 memcpy(fc->nmvc_1_sign_cdf, default_nmv_context.comps[1].sign_cdf, sizeof(default_nmv_context.comps[1].sign_cdf));
1280 memcpy(fc->ndvc_joints_cdf, default_nmv_context.joints_cdf, sizeof(default_nmv_context.joints_cdf));
1281 memcpy(fc->ndvc_0_bits_cdf, default_nmv_context.comps[0].bits_cdf, sizeof(default_nmv_context.comps[0].bits_cdf));
1282 memcpy(fc->ndvc_0_class0_cdf, default_nmv_context.comps[0].class0_cdf, sizeof(default_nmv_context.comps[0].class0_cdf));
1283 memcpy(fc->ndvc_0_class0_fp_cdf, default_nmv_context.comps[0].class0_fp_cdf, sizeof(default_nmv_context.comps[0].class0_fp_cdf));
1284 memcpy(fc->ndvc_0_class0_hp_cdf, default_nmv_context.comps[0].class0_hp_cdf, sizeof(default_nmv_context.comps[0].class0_hp_cdf));
1285 memcpy(fc->ndvc_0_classes_cdf, default_nmv_context.comps[0].classes_cdf, sizeof(default_nmv_context.comps[0].classes_cdf));
1286 memcpy(fc->ndvc_0_fp_cdf, default_nmv_context.comps[0].fp_cdf, sizeof(default_nmv_context.comps[0].fp_cdf));
1287 memcpy(fc->ndvc_0_hp_cdf, default_nmv_context.comps[0].hp_cdf, sizeof(default_nmv_context.comps[0].hp_cdf));
1288 memcpy(fc->ndvc_0_sign_cdf, default_nmv_context.comps[0].sign_cdf, sizeof(default_nmv_context.comps[0].sign_cdf));
1289 memcpy(fc->ndvc_1_bits_cdf, default_nmv_context.comps[1].bits_cdf, sizeof(default_nmv_context.comps[1].bits_cdf));
1290 memcpy(fc->ndvc_1_class0_cdf, default_nmv_context.comps[1].class0_cdf, sizeof(default_nmv_context.comps[1].class0_cdf));
1291 memcpy(fc->ndvc_1_class0_fp_cdf, default_nmv_context.comps[1].class0_fp_cdf, sizeof(default_nmv_context.comps[1].class0_fp_cdf));
1292 memcpy(fc->ndvc_1_class0_hp_cdf, default_nmv_context.comps[1].class0_hp_cdf, sizeof(default_nmv_context.comps[1].class0_hp_cdf));
1293 memcpy(fc->ndvc_1_classes_cdf, default_nmv_context.comps[1].classes_cdf, sizeof(default_nmv_context.comps[1].classes_cdf));
1294 memcpy(fc->ndvc_1_fp_cdf, default_nmv_context.comps[1].fp_cdf, sizeof(default_nmv_context.comps[1].fp_cdf));
1295 memcpy(fc->ndvc_1_hp_cdf, default_nmv_context.comps[1].hp_cdf, sizeof(default_nmv_context.comps[1].hp_cdf));
1296 memcpy(fc->ndvc_1_sign_cdf, default_nmv_context.comps[1].sign_cdf, sizeof(default_nmv_context.comps[1].sign_cdf));
1297 }
1298
rvcn_av1_default_coef_probs(void *prob, int index)1299 static void rvcn_av1_default_coef_probs(void *prob, int index)
1300 {
1301 rvcn_av1_frame_context_t * fc = (rvcn_av1_frame_context_t*)prob;
1302
1303 memcpy(fc->txb_skip_cdf, av1_default_txb_skip_cdfs[index], sizeof(av1_default_txb_skip_cdfs[index]));
1304 memcpy(fc->eob_extra_cdf, av1_default_eob_extra_cdfs[index], sizeof(av1_default_eob_extra_cdfs[index]));
1305 memcpy(fc->dc_sign_cdf, av1_default_dc_sign_cdfs[index], sizeof(av1_default_dc_sign_cdfs[index]));
1306 memcpy(fc->coeff_br_cdf, av1_default_coeff_lps_multi_cdfs[index], sizeof(av1_default_coeff_lps_multi_cdfs[index]));
1307 memcpy(fc->coeff_base_cdf, av1_default_coeff_base_multi_cdfs[index], sizeof(av1_default_coeff_base_multi_cdfs[index]));
1308 memcpy(fc->coeff_base_eob_cdf, av1_default_coeff_base_eob_multi_cdfs[index], sizeof(av1_default_coeff_base_eob_multi_cdfs[index]));
1309 memcpy(fc->eob_flag_cdf16, av1_default_eob_multi16_cdfs[index], sizeof(av1_default_eob_multi16_cdfs[index]));
1310 memcpy(fc->eob_flag_cdf32, av1_default_eob_multi32_cdfs[index], sizeof(av1_default_eob_multi32_cdfs[index]));
1311 memcpy(fc->eob_flag_cdf64, av1_default_eob_multi64_cdfs[index], sizeof(av1_default_eob_multi64_cdfs[index]));
1312 memcpy(fc->eob_flag_cdf128, av1_default_eob_multi128_cdfs[index], sizeof(av1_default_eob_multi128_cdfs[index]));
1313 memcpy(fc->eob_flag_cdf256, av1_default_eob_multi256_cdfs[index], sizeof(av1_default_eob_multi256_cdfs[index]));
1314 memcpy(fc->eob_flag_cdf512, av1_default_eob_multi512_cdfs[index], sizeof(av1_default_eob_multi512_cdfs[index]));
1315 memcpy(fc->eob_flag_cdf1024, av1_default_eob_multi1024_cdfs[index], sizeof(av1_default_eob_multi1024_cdfs[index]));
1316 }
1317
rvcn_vcn4_av1_default_coef_probs(void *prob, int index)1318 static void rvcn_vcn4_av1_default_coef_probs(void *prob, int index)
1319 {
1320 rvcn_av1_vcn4_frame_context_t *fc = (rvcn_av1_vcn4_frame_context_t*)prob;
1321 void *p;
1322 int i, j;
1323 unsigned size;
1324
1325 memcpy(fc->txb_skip_cdf, av1_default_txb_skip_cdfs[index], sizeof(av1_default_txb_skip_cdfs[index]));
1326
1327 p = (void *)fc->eob_extra_cdf;
1328 size = sizeof(av1_default_eob_extra_cdfs[0][0][0][0]) * EOB_COEF_CONTEXTS_VCN4;
1329 for (i = 0; i < AV1_TX_SIZES; i++) {
1330 for ( j = 0; j < AV1_PLANE_TYPES; j++) {
1331 memcpy(p, &av1_default_eob_extra_cdfs[index][i][j][3], size);
1332 p += size;
1333 }
1334 }
1335
1336 memcpy(fc->dc_sign_cdf, av1_default_dc_sign_cdfs[index], sizeof(av1_default_dc_sign_cdfs[index]));
1337 memcpy(fc->coeff_br_cdf, av1_default_coeff_lps_multi_cdfs[index], sizeof(av1_default_coeff_lps_multi_cdfs[index]));
1338 memcpy(fc->coeff_base_cdf, av1_default_coeff_base_multi_cdfs[index], sizeof(av1_default_coeff_base_multi_cdfs[index]));
1339 memcpy(fc->coeff_base_eob_cdf, av1_default_coeff_base_eob_multi_cdfs[index], sizeof(av1_default_coeff_base_eob_multi_cdfs[index]));
1340 memcpy(fc->eob_flag_cdf16, av1_default_eob_multi16_cdfs[index], sizeof(av1_default_eob_multi16_cdfs[index]));
1341 memcpy(fc->eob_flag_cdf32, av1_default_eob_multi32_cdfs[index], sizeof(av1_default_eob_multi32_cdfs[index]));
1342 memcpy(fc->eob_flag_cdf64, av1_default_eob_multi64_cdfs[index], sizeof(av1_default_eob_multi64_cdfs[index]));
1343 memcpy(fc->eob_flag_cdf128, av1_default_eob_multi128_cdfs[index], sizeof(av1_default_eob_multi128_cdfs[index]));
1344 memcpy(fc->eob_flag_cdf256, av1_default_eob_multi256_cdfs[index], sizeof(av1_default_eob_multi256_cdfs[index]));
1345 memcpy(fc->eob_flag_cdf512, av1_default_eob_multi512_cdfs[index], sizeof(av1_default_eob_multi512_cdfs[index]));
1346 memcpy(fc->eob_flag_cdf1024, av1_default_eob_multi1024_cdfs[index], sizeof(av1_default_eob_multi1024_cdfs[index]));
1347 }
1348
calc_ctx_size_h265_main(struct radeon_decoder *dec)1349 static unsigned calc_ctx_size_h265_main(struct radeon_decoder *dec)
1350 {
1351 unsigned width = align(dec->base.width, VL_MACROBLOCK_WIDTH);
1352 unsigned height = align(dec->base.height, VL_MACROBLOCK_HEIGHT);
1353
1354 unsigned max_references = dec->base.max_references + 1;
1355
1356 if (dec->base.width * dec->base.height >= 4096 * 2000)
1357 max_references = MAX2(max_references, 8);
1358 else
1359 max_references = MAX2(max_references, 17);
1360
1361 width = align(width, 16);
1362 height = align(height, 16);
1363 return ((width + 255) / 16) * ((height + 255) / 16) * 16 * max_references + 52 * 1024;
1364 }
1365
calc_ctx_size_h265_main10(struct radeon_decoder *dec, struct pipe_h265_picture_desc *pic)1366 static unsigned calc_ctx_size_h265_main10(struct radeon_decoder *dec,
1367 struct pipe_h265_picture_desc *pic)
1368 {
1369 unsigned log2_ctb_size, width_in_ctb, height_in_ctb, num_16x16_block_per_ctb;
1370 unsigned context_buffer_size_per_ctb_row, cm_buffer_size, max_mb_address, db_left_tile_pxl_size;
1371 unsigned db_left_tile_ctx_size = 4096 / 16 * (32 + 16 * 4);
1372
1373 unsigned width = align(dec->base.width, VL_MACROBLOCK_WIDTH);
1374 unsigned height = align(dec->base.height, VL_MACROBLOCK_HEIGHT);
1375 unsigned coeff_10bit =
1376 (pic->pps->sps->bit_depth_luma_minus8 || pic->pps->sps->bit_depth_chroma_minus8) ? 2 : 1;
1377
1378 unsigned max_references = dec->base.max_references + 1;
1379
1380 if (dec->base.width * dec->base.height >= 4096 * 2000)
1381 max_references = MAX2(max_references, 8);
1382 else
1383 max_references = MAX2(max_references, 17);
1384
1385 log2_ctb_size = pic->pps->sps->log2_min_luma_coding_block_size_minus3 + 3 +
1386 pic->pps->sps->log2_diff_max_min_luma_coding_block_size;
1387
1388 width_in_ctb = (width + ((1 << log2_ctb_size) - 1)) >> log2_ctb_size;
1389 height_in_ctb = (height + ((1 << log2_ctb_size) - 1)) >> log2_ctb_size;
1390
1391 num_16x16_block_per_ctb = ((1 << log2_ctb_size) >> 4) * ((1 << log2_ctb_size) >> 4);
1392 context_buffer_size_per_ctb_row = align(width_in_ctb * num_16x16_block_per_ctb * 16, 256);
1393 max_mb_address = (unsigned)ceil(height * 8 / 2048.0);
1394
1395 cm_buffer_size = max_references * context_buffer_size_per_ctb_row * height_in_ctb;
1396 db_left_tile_pxl_size = coeff_10bit * (max_mb_address * 2 * 2048 + 1024);
1397
1398 return cm_buffer_size + db_left_tile_ctx_size + db_left_tile_pxl_size;
1399 }
1400
get_vc1_msg(struct pipe_vc1_picture_desc *pic)1401 static rvcn_dec_message_vc1_t get_vc1_msg(struct pipe_vc1_picture_desc *pic)
1402 {
1403 rvcn_dec_message_vc1_t result;
1404
1405 memset(&result, 0, sizeof(result));
1406 switch (pic->base.profile) {
1407 case PIPE_VIDEO_PROFILE_VC1_SIMPLE:
1408 result.profile = RDECODE_VC1_PROFILE_SIMPLE;
1409 result.level = 1;
1410 break;
1411
1412 case PIPE_VIDEO_PROFILE_VC1_MAIN:
1413 result.profile = RDECODE_VC1_PROFILE_MAIN;
1414 result.level = 2;
1415 break;
1416
1417 case PIPE_VIDEO_PROFILE_VC1_ADVANCED:
1418 result.profile = RDECODE_VC1_PROFILE_ADVANCED;
1419 result.level = 4;
1420 break;
1421
1422 default:
1423 assert(0);
1424 }
1425
1426 result.sps_info_flags |= pic->postprocflag << 7;
1427 result.sps_info_flags |= pic->pulldown << 6;
1428 result.sps_info_flags |= pic->interlace << 5;
1429 result.sps_info_flags |= pic->tfcntrflag << 4;
1430 result.sps_info_flags |= pic->finterpflag << 3;
1431 result.sps_info_flags |= pic->psf << 1;
1432
1433 result.pps_info_flags |= pic->range_mapy_flag << 31;
1434 result.pps_info_flags |= pic->range_mapy << 28;
1435 result.pps_info_flags |= pic->range_mapuv_flag << 27;
1436 result.pps_info_flags |= pic->range_mapuv << 24;
1437 result.pps_info_flags |= pic->multires << 21;
1438 result.pps_info_flags |= pic->maxbframes << 16;
1439 result.pps_info_flags |= pic->overlap << 11;
1440 result.pps_info_flags |= pic->quantizer << 9;
1441 result.pps_info_flags |= pic->panscan_flag << 7;
1442 result.pps_info_flags |= pic->refdist_flag << 6;
1443 result.pps_info_flags |= pic->vstransform << 0;
1444
1445 if (pic->base.profile != PIPE_VIDEO_PROFILE_VC1_SIMPLE) {
1446 result.pps_info_flags |= pic->syncmarker << 20;
1447 result.pps_info_flags |= pic->rangered << 19;
1448 result.pps_info_flags |= pic->loopfilter << 5;
1449 result.pps_info_flags |= pic->fastuvmc << 4;
1450 result.pps_info_flags |= pic->extended_mv << 3;
1451 result.pps_info_flags |= pic->extended_dmv << 8;
1452 result.pps_info_flags |= pic->dquant << 1;
1453 }
1454
1455 result.chroma_format = 1;
1456
1457 return result;
1458 }
1459
get_ref_pic_idx(struct radeon_decoder *dec, struct pipe_video_buffer *ref)1460 static uint32_t get_ref_pic_idx(struct radeon_decoder *dec, struct pipe_video_buffer *ref)
1461 {
1462 uint32_t min = MAX2(dec->frame_number, NUM_MPEG2_REFS) - NUM_MPEG2_REFS;
1463 uint32_t max = MAX2(dec->frame_number, 1) - 1;
1464 uintptr_t frame;
1465
1466 /* seems to be the most sane fallback */
1467 if (!ref)
1468 return max;
1469
1470 /* get the frame number from the associated data */
1471 frame = (uintptr_t)vl_video_buffer_get_associated_data(ref, &dec->base);
1472
1473 /* limit the frame number to a valid range */
1474 return MAX2(MIN2(frame, max), min);
1475 }
1476
get_mpeg2_msg(struct radeon_decoder *dec, struct pipe_mpeg12_picture_desc *pic)1477 static rvcn_dec_message_mpeg2_vld_t get_mpeg2_msg(struct radeon_decoder *dec,
1478 struct pipe_mpeg12_picture_desc *pic)
1479 {
1480 const int *zscan = pic->alternate_scan ? vl_zscan_alternate : vl_zscan_normal;
1481 rvcn_dec_message_mpeg2_vld_t result;
1482 unsigned i;
1483
1484 memset(&result, 0, sizeof(result));
1485 result.decoded_pic_idx = dec->frame_number;
1486
1487 result.forward_ref_pic_idx = get_ref_pic_idx(dec, pic->ref[0]);
1488 result.backward_ref_pic_idx = get_ref_pic_idx(dec, pic->ref[1]);
1489
1490 if (pic->intra_matrix) {
1491 result.load_intra_quantiser_matrix = 1;
1492 for (i = 0; i < 64; ++i) {
1493 result.intra_quantiser_matrix[i] = pic->intra_matrix[zscan[i]];
1494 }
1495 }
1496 if (pic->non_intra_matrix) {
1497 result.load_nonintra_quantiser_matrix = 1;
1498 for (i = 0; i < 64; ++i) {
1499 result.nonintra_quantiser_matrix[i] = pic->non_intra_matrix[zscan[i]];
1500 }
1501 }
1502
1503 result.profile_and_level_indication = 0;
1504 result.chroma_format = 0x1;
1505
1506 result.picture_coding_type = pic->picture_coding_type;
1507 result.f_code[0][0] = pic->f_code[0][0] + 1;
1508 result.f_code[0][1] = pic->f_code[0][1] + 1;
1509 result.f_code[1][0] = pic->f_code[1][0] + 1;
1510 result.f_code[1][1] = pic->f_code[1][1] + 1;
1511 result.intra_dc_precision = pic->intra_dc_precision;
1512 result.pic_structure = pic->picture_structure;
1513 result.top_field_first = pic->top_field_first;
1514 result.frame_pred_frame_dct = pic->frame_pred_frame_dct;
1515 result.concealment_motion_vectors = pic->concealment_motion_vectors;
1516 result.q_scale_type = pic->q_scale_type;
1517 result.intra_vlc_format = pic->intra_vlc_format;
1518 result.alternate_scan = pic->alternate_scan;
1519
1520 return result;
1521 }
1522
get_mpeg4_msg(struct radeon_decoder *dec, struct pipe_mpeg4_picture_desc *pic)1523 static rvcn_dec_message_mpeg4_asp_vld_t get_mpeg4_msg(struct radeon_decoder *dec,
1524 struct pipe_mpeg4_picture_desc *pic)
1525 {
1526 rvcn_dec_message_mpeg4_asp_vld_t result;
1527 unsigned i;
1528
1529 memset(&result, 0, sizeof(result));
1530 result.decoded_pic_idx = dec->frame_number;
1531
1532 result.forward_ref_pic_idx = get_ref_pic_idx(dec, pic->ref[0]);
1533 result.backward_ref_pic_idx = get_ref_pic_idx(dec, pic->ref[1]);
1534
1535 result.variant_type = 0;
1536 result.profile_and_level_indication = 0xF0;
1537
1538 result.video_object_layer_verid = 0x5;
1539 result.video_object_layer_shape = 0x0;
1540
1541 result.video_object_layer_width = dec->base.width;
1542 result.video_object_layer_height = dec->base.height;
1543
1544 result.vop_time_increment_resolution = pic->vop_time_increment_resolution;
1545
1546 result.short_video_header = pic->short_video_header;
1547 result.interlaced = pic->interlaced;
1548 result.load_intra_quant_mat = 1;
1549 result.load_nonintra_quant_mat = 1;
1550 result.quarter_sample = pic->quarter_sample;
1551 result.complexity_estimation_disable = 1;
1552 result.resync_marker_disable = pic->resync_marker_disable;
1553 result.newpred_enable = 0;
1554 result.reduced_resolution_vop_enable = 0;
1555
1556 result.quant_type = pic->quant_type;
1557
1558 for (i = 0; i < 64; ++i) {
1559 result.intra_quant_mat[i] = pic->intra_matrix[vl_zscan_normal[i]];
1560 result.nonintra_quant_mat[i] = pic->non_intra_matrix[vl_zscan_normal[i]];
1561 }
1562
1563 return result;
1564 }
1565
rvcn_dec_message_create(struct radeon_decoder *dec)1566 static void rvcn_dec_message_create(struct radeon_decoder *dec)
1567 {
1568 rvcn_dec_message_header_t *header = dec->msg;
1569 rvcn_dec_message_create_t *create = dec->msg + sizeof(rvcn_dec_message_header_t);
1570 unsigned sizes = sizeof(rvcn_dec_message_header_t) + sizeof(rvcn_dec_message_create_t);
1571
1572 memset(dec->msg, 0, sizes);
1573 header->header_size = sizeof(rvcn_dec_message_header_t);
1574 header->total_size = sizes;
1575 header->num_buffers = 1;
1576 header->msg_type = RDECODE_MSG_CREATE;
1577 header->stream_handle = dec->stream_handle;
1578 header->status_report_feedback_number = 0;
1579
1580 header->index[0].message_id = RDECODE_MESSAGE_CREATE;
1581 header->index[0].offset = sizeof(rvcn_dec_message_header_t);
1582 header->index[0].size = sizeof(rvcn_dec_message_create_t);
1583 header->index[0].filled = 0;
1584
1585 create->stream_type = dec->stream_type;
1586 create->session_flags = 0;
1587 create->width_in_samples = dec->base.width;
1588 create->height_in_samples = dec->base.height;
1589 }
1590
rvcn_dec_dynamic_dpb_t2_message(struct radeon_decoder *dec, rvcn_dec_message_decode_t *decode, rvcn_dec_message_dynamic_dpb_t2_t *dynamic_dpb_t2, bool encrypted)1591 static unsigned rvcn_dec_dynamic_dpb_t2_message(struct radeon_decoder *dec, rvcn_dec_message_decode_t *decode,
1592 rvcn_dec_message_dynamic_dpb_t2_t *dynamic_dpb_t2, bool encrypted)
1593 {
1594 struct rvcn_dec_dynamic_dpb_t2 *dpb = NULL, *dummy = NULL;
1595 unsigned width, height, size;
1596 uint64_t addr;
1597 int i;
1598
1599 width = align(decode->width_in_samples, dec->db_alignment);
1600 height = align(decode->height_in_samples, dec->db_alignment);
1601 size = align((width * height * 3) / 2, 256);
1602 if (dec->ref_codec.bts == CODEC_10_BITS)
1603 size = size * 3 / 2;
1604
1605 list_for_each_entry_safe(struct rvcn_dec_dynamic_dpb_t2, d, &dec->dpb_ref_list, list) {
1606 for (i = 0; i < dec->ref_codec.ref_size; ++i) {
1607 if (((dec->ref_codec.ref_list[i] & 0x7f) != 0x7f) && (d->index == (dec->ref_codec.ref_list[i] & 0x7f))) {
1608 if (!dummy)
1609 dummy = d;
1610
1611 addr = dec->ws->buffer_get_virtual_address(d->dpb.res->buf);
1612 if (!addr && dummy) {
1613 RVID_ERR("Ref list from application is incorrect, using dummy buffer instead.\n");
1614 addr = dec->ws->buffer_get_virtual_address(dummy->dpb.res->buf);
1615 }
1616 dynamic_dpb_t2->dpbAddrLo[i] = addr;
1617 dynamic_dpb_t2->dpbAddrHi[i] = addr >> 32;
1618 ++dynamic_dpb_t2->dpbArraySize;
1619 break;
1620 }
1621 }
1622 if (i == dec->ref_codec.ref_size) {
1623 if (d->dpb.res->b.b.width0 * d->dpb.res->b.b.height0 != size) {
1624 list_del(&d->list);
1625 list_addtail(&d->list, &dec->dpb_unref_list);
1626 } else {
1627 d->index = 0x7f;
1628 }
1629 }
1630 }
1631
1632 list_for_each_entry_safe(struct rvcn_dec_dynamic_dpb_t2, d, &dec->dpb_ref_list, list) {
1633 if (d->dpb.res->b.b.width0 * d->dpb.res->b.b.height0 == size && d->index == dec->ref_codec.index) {
1634 dpb = d;
1635 break;
1636 }
1637 }
1638
1639 if (!dpb) {
1640 list_for_each_entry_safe(struct rvcn_dec_dynamic_dpb_t2, d, &dec->dpb_ref_list, list) {
1641 if (d->index == 0x7f) {
1642 d->index = dec->ref_codec.index;
1643 dpb = d;
1644 break;
1645 }
1646 }
1647 }
1648
1649 list_for_each_entry_safe(struct rvcn_dec_dynamic_dpb_t2, d, &dec->dpb_unref_list, list) {
1650 list_del(&d->list);
1651 si_vid_destroy_buffer(&d->dpb);
1652 FREE(d);
1653 }
1654
1655 if (!dpb) {
1656 bool r;
1657 dpb = CALLOC_STRUCT(rvcn_dec_dynamic_dpb_t2);
1658 if (!dpb)
1659 return 1;
1660 dpb->index = dec->ref_codec.index;
1661 if (encrypted)
1662 r = si_vid_create_tmz_buffer(dec->screen, &dpb->dpb, size, PIPE_USAGE_DEFAULT);
1663 else
1664 r = si_vid_create_buffer(dec->screen, &dpb->dpb, size, PIPE_USAGE_DEFAULT);
1665 assert(encrypted == (bool)(dpb->dpb.res->flags & RADEON_FLAG_ENCRYPTED));
1666
1667 if (!r) {
1668 RVID_ERR("Can't allocated dpb buffer.\n");
1669 FREE(dpb);
1670 return 1;
1671 }
1672 list_addtail(&dpb->list, &dec->dpb_ref_list);
1673 }
1674
1675 dec->ws->cs_add_buffer(&dec->cs, dpb->dpb.res->buf,
1676 RADEON_USAGE_READWRITE | RADEON_USAGE_SYNCHRONIZED, RADEON_DOMAIN_VRAM);
1677 addr = dec->ws->buffer_get_virtual_address(dpb->dpb.res->buf);
1678 dynamic_dpb_t2->dpbCurrLo = addr;
1679 dynamic_dpb_t2->dpbCurrHi = addr >> 32;
1680
1681 decode->decode_flags = 1;
1682 dynamic_dpb_t2->dpbConfigFlags = 0;
1683 dynamic_dpb_t2->dpbLumaPitch = align(decode->width_in_samples, dec->db_alignment);
1684 dynamic_dpb_t2->dpbLumaAlignedHeight = align(decode->height_in_samples, dec->db_alignment);
1685 dynamic_dpb_t2->dpbLumaAlignedSize = dynamic_dpb_t2->dpbLumaPitch *
1686 dynamic_dpb_t2->dpbLumaAlignedHeight;
1687 dynamic_dpb_t2->dpbChromaPitch = dynamic_dpb_t2->dpbLumaPitch >> 1;
1688 dynamic_dpb_t2->dpbChromaAlignedHeight = dynamic_dpb_t2->dpbLumaAlignedHeight >> 1;
1689 dynamic_dpb_t2->dpbChromaAlignedSize = dynamic_dpb_t2->dpbChromaPitch *
1690 dynamic_dpb_t2->dpbChromaAlignedHeight * 2;
1691
1692 if (dec->ref_codec.bts == CODEC_10_BITS) {
1693 dynamic_dpb_t2->dpbLumaAlignedSize = dynamic_dpb_t2->dpbLumaAlignedSize * 3 / 2;
1694 dynamic_dpb_t2->dpbChromaAlignedSize = dynamic_dpb_t2->dpbChromaAlignedSize * 3 / 2;
1695 }
1696
1697 return 0;
1698 }
1699
rvcn_dec_message_decode(struct radeon_decoder *dec, struct pipe_video_buffer *target, struct pipe_picture_desc *picture)1700 static struct pb_buffer *rvcn_dec_message_decode(struct radeon_decoder *dec,
1701 struct pipe_video_buffer *target,
1702 struct pipe_picture_desc *picture)
1703 {
1704 DECRYPT_PARAMETERS *decrypt = (DECRYPT_PARAMETERS *)picture->decrypt_key;
1705 bool encrypted = (DECRYPT_PARAMETERS *)picture->protected_playback;
1706 struct si_texture *luma = (struct si_texture *)((struct vl_video_buffer *)target)->resources[0];
1707 struct si_texture *chroma =
1708 (struct si_texture *)((struct vl_video_buffer *)target)->resources[1];
1709 ASSERTED struct si_screen *sscreen = (struct si_screen *)dec->screen;
1710 rvcn_dec_message_header_t *header;
1711 rvcn_dec_message_index_t *index_codec;
1712 rvcn_dec_message_index_t *index_drm = NULL;
1713 rvcn_dec_message_index_t *index_dynamic_dpb = NULL;
1714 rvcn_dec_message_decode_t *decode;
1715 unsigned sizes = 0, offset_decode, offset_codec;
1716 unsigned offset_drm = 0, offset_dynamic_dpb = 0;
1717 void *codec;
1718 rvcn_dec_message_drm_t *drm = NULL;
1719 rvcn_dec_message_dynamic_dpb_t *dynamic_dpb = NULL;
1720 rvcn_dec_message_dynamic_dpb_t2_t *dynamic_dpb_t2 = NULL;
1721
1722 header = dec->msg;
1723 sizes += sizeof(rvcn_dec_message_header_t);
1724
1725 index_codec = (void*)header + sizes;
1726 sizes += sizeof(rvcn_dec_message_index_t);
1727
1728 if (encrypted) {
1729 index_drm = (void*)header + sizes;
1730 sizes += sizeof(rvcn_dec_message_index_t);
1731 }
1732
1733 if (dec->dpb_type >= DPB_DYNAMIC_TIER_1) {
1734 index_dynamic_dpb = (void*)header + sizes;
1735 sizes += sizeof(rvcn_dec_message_index_t);
1736 }
1737
1738 offset_decode = sizes;
1739 decode = (void*)header + sizes;
1740 sizes += sizeof(rvcn_dec_message_decode_t);
1741
1742 if (encrypted) {
1743 offset_drm = sizes;
1744 drm = (void*)header + sizes;
1745 sizes += sizeof(rvcn_dec_message_drm_t);
1746 }
1747
1748 if (dec->dpb_type >= DPB_DYNAMIC_TIER_1) {
1749 offset_dynamic_dpb = sizes;
1750 if (dec->dpb_type == DPB_DYNAMIC_TIER_1) {
1751 dynamic_dpb = (void*)header + sizes;
1752 sizes += sizeof(rvcn_dec_message_dynamic_dpb_t);
1753 }
1754 else if (dec->dpb_type == DPB_DYNAMIC_TIER_2) {
1755 dynamic_dpb_t2 = (void*)header + sizes;
1756 sizes += sizeof(rvcn_dec_message_dynamic_dpb_t2_t);
1757 }
1758 }
1759
1760 offset_codec = sizes;
1761 codec = (void*)header + sizes;
1762
1763 memset(dec->msg, 0, sizes);
1764 header->header_size = sizeof(rvcn_dec_message_header_t);
1765 header->total_size = sizes;
1766 header->msg_type = RDECODE_MSG_DECODE;
1767 header->stream_handle = dec->stream_handle;
1768 header->status_report_feedback_number = dec->frame_number;
1769
1770 header->index[0].message_id = RDECODE_MESSAGE_DECODE;
1771 header->index[0].offset = offset_decode;
1772 header->index[0].size = sizeof(rvcn_dec_message_decode_t);
1773 header->index[0].filled = 0;
1774 header->num_buffers = 1;
1775
1776 index_codec->offset = offset_codec;
1777 index_codec->size = sizeof(rvcn_dec_message_avc_t);
1778 index_codec->filled = 0;
1779 ++header->num_buffers;
1780
1781 if (encrypted) {
1782 index_drm->message_id = RDECODE_MESSAGE_DRM;
1783 index_drm->offset = offset_drm;
1784 index_drm->size = sizeof(rvcn_dec_message_drm_t);
1785 index_drm->filled = 0;
1786 ++header->num_buffers;
1787 }
1788
1789 if (dec->dpb_type >= DPB_DYNAMIC_TIER_1) {
1790 index_dynamic_dpb->message_id = RDECODE_MESSAGE_DYNAMIC_DPB;
1791 index_dynamic_dpb->offset = offset_dynamic_dpb;
1792 index_dynamic_dpb->filled = 0;
1793 ++header->num_buffers;
1794 if (dec->dpb_type == DPB_DYNAMIC_TIER_1)
1795 index_dynamic_dpb->size = sizeof(rvcn_dec_message_dynamic_dpb_t);
1796 else if (dec->dpb_type == DPB_DYNAMIC_TIER_2)
1797 index_dynamic_dpb->size = sizeof(rvcn_dec_message_dynamic_dpb_t2_t);
1798 }
1799
1800 decode->stream_type = dec->stream_type;
1801 decode->decode_flags = 0;
1802 decode->width_in_samples = dec->base.width;
1803 decode->height_in_samples = dec->base.height;
1804
1805 decode->bsd_size = align(dec->bs_size, 128);
1806
1807 if (!dec->dpb.res && dec->dpb_type != DPB_DYNAMIC_TIER_2) {
1808 bool r;
1809 if (dec->dpb_size) {
1810 if (encrypted) {
1811 r = si_vid_create_tmz_buffer(dec->screen, &dec->dpb, dec->dpb_size, PIPE_USAGE_DEFAULT);
1812 } else {
1813 r = si_vid_create_buffer(dec->screen, &dec->dpb, dec->dpb_size, PIPE_USAGE_DEFAULT);
1814 }
1815 assert(encrypted == (bool)(dec->dpb.res->flags & RADEON_FLAG_ENCRYPTED));
1816 if (!r) {
1817 RVID_ERR("Can't allocated dpb.\n");
1818 return NULL;
1819 }
1820 si_vid_clear_buffer(dec->base.context, &dec->dpb);
1821 }
1822 }
1823
1824 if (!dec->ctx.res) {
1825 enum pipe_video_format fmt = u_reduce_video_profile(picture->profile);
1826 if (dec->stream_type == RDECODE_CODEC_H264_PERF) {
1827 unsigned ctx_size = calc_ctx_size_h264_perf(dec);
1828 bool r;
1829 if (encrypted && dec->tmz_ctx) {
1830 r = si_vid_create_tmz_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT);
1831 } else {
1832 r = si_vid_create_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT);
1833 }
1834 assert((encrypted && dec->tmz_ctx) == (bool)(dec->ctx.res->flags & RADEON_FLAG_ENCRYPTED));
1835
1836 if (!r) {
1837 RVID_ERR("Can't allocated context buffer.\n");
1838 return NULL;
1839 }
1840 si_vid_clear_buffer(dec->base.context, &dec->ctx);
1841 } else if (fmt == PIPE_VIDEO_FORMAT_VP9) {
1842 unsigned ctx_size;
1843 uint8_t *ptr;
1844 bool r;
1845
1846 /* default probability + probability data */
1847 ctx_size = 2304 * 5;
1848
1849 if (((struct si_screen *)dec->screen)->info.family >= CHIP_RENOIR) {
1850 /* SRE collocated context data */
1851 ctx_size += 32 * 2 * 128 * 68;
1852 /* SMP collocated context data */
1853 ctx_size += 9 * 64 * 2 * 128 * 68;
1854 /* SDB left tile pixel */
1855 ctx_size += 8 * 2 * 2 * 8192;
1856 } else {
1857 ctx_size += 32 * 2 * 64 * 64;
1858 ctx_size += 9 * 64 * 2 * 64 * 64;
1859 ctx_size += 8 * 2 * 4096;
1860 }
1861
1862 if (dec->base.profile == PIPE_VIDEO_PROFILE_VP9_PROFILE2)
1863 ctx_size += 8 * 2 * 4096;
1864
1865 if (encrypted && dec->tmz_ctx) {
1866 r = si_vid_create_tmz_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT);
1867 } else {
1868 r = si_vid_create_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT);
1869 }
1870 if (!r) {
1871 RVID_ERR("Can't allocated context buffer.\n");
1872 return NULL;
1873 }
1874 si_vid_clear_buffer(dec->base.context, &dec->ctx);
1875
1876 /* ctx needs probs table */
1877 ptr = dec->ws->buffer_map(dec->ws, dec->ctx.res->buf, &dec->cs,
1878 PIPE_MAP_WRITE | RADEON_MAP_TEMPORARY);
1879 fill_probs_table(ptr);
1880 dec->ws->buffer_unmap(dec->ws, dec->ctx.res->buf);
1881 dec->bs_ptr = NULL;
1882 } else if (fmt == PIPE_VIDEO_FORMAT_HEVC) {
1883 unsigned ctx_size;
1884 bool r;
1885 if (dec->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10)
1886 ctx_size = calc_ctx_size_h265_main10(dec, (struct pipe_h265_picture_desc *)picture);
1887 else
1888 ctx_size = calc_ctx_size_h265_main(dec);
1889
1890 if (encrypted && dec->tmz_ctx) {
1891 r = si_vid_create_tmz_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT);
1892 } else {
1893 r = si_vid_create_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT);
1894 }
1895 if (!r) {
1896 RVID_ERR("Can't allocated context buffer.\n");
1897 return NULL;
1898 }
1899 si_vid_clear_buffer(dec->base.context, &dec->ctx);
1900 }
1901 }
1902 if (encrypted != dec->ws->cs_is_secure(&dec->cs)) {
1903 dec->ws->cs_flush(&dec->cs, RADEON_FLUSH_TOGGLE_SECURE_SUBMISSION, NULL);
1904 }
1905
1906 decode->dpb_size = (dec->dpb_type != DPB_DYNAMIC_TIER_2) ? dec->dpb.res->buf->size : 0;
1907 decode->dt_size = si_resource(((struct vl_video_buffer *)target)->resources[0])->buf->size +
1908 si_resource(((struct vl_video_buffer *)target)->resources[1])->buf->size;
1909
1910 decode->sct_size = 0;
1911 decode->sc_coeff_size = 0;
1912
1913 decode->sw_ctxt_size = RDECODE_SESSION_CONTEXT_SIZE;
1914 decode->db_pitch = align(dec->base.width, dec->db_alignment);
1915
1916 if (((struct si_screen*)dec->screen)->info.family >= CHIP_NAVI21 &&
1917 (dec->stream_type == RDECODE_CODEC_VP9 || dec->stream_type == RDECODE_CODEC_AV1 ||
1918 dec->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10))
1919 decode->db_aligned_height = align(dec->base.height, 64);
1920
1921 decode->db_surf_tile_config = 0;
1922 decode->db_array_mode = dec->addr_gfx_mode;
1923
1924 decode->dt_pitch = luma->surface.u.gfx9.surf_pitch * luma->surface.blk_w;
1925 decode->dt_uv_pitch = chroma->surface.u.gfx9.surf_pitch * chroma->surface.blk_w;
1926
1927 if (luma->surface.meta_offset) {
1928 RVID_ERR("DCC surfaces not supported.\n");
1929 return NULL;
1930 }
1931
1932 decode->dt_tiling_mode = 0;
1933 decode->dt_swizzle_mode = luma->surface.u.gfx9.swizzle_mode;
1934 decode->dt_array_mode = dec->addr_gfx_mode;
1935 decode->dt_field_mode = ((struct vl_video_buffer *)target)->base.interlaced;
1936 decode->dt_surf_tile_config = 0;
1937 decode->dt_uv_surf_tile_config = 0;
1938
1939 decode->dt_luma_top_offset = luma->surface.u.gfx9.surf_offset;
1940 decode->dt_chroma_top_offset = chroma->surface.u.gfx9.surf_offset;
1941 if (decode->dt_field_mode) {
1942 decode->dt_luma_bottom_offset =
1943 luma->surface.u.gfx9.surf_offset + luma->surface.u.gfx9.surf_slice_size;
1944 decode->dt_chroma_bottom_offset =
1945 chroma->surface.u.gfx9.surf_offset + chroma->surface.u.gfx9.surf_slice_size;
1946 } else {
1947 decode->dt_luma_bottom_offset = decode->dt_luma_top_offset;
1948 decode->dt_chroma_bottom_offset = decode->dt_chroma_top_offset;
1949 }
1950 if (dec->stream_type == RDECODE_CODEC_AV1)
1951 decode->db_pitch_uv = chroma->surface.u.gfx9.surf_pitch * chroma->surface.blk_w;
1952
1953 if (encrypted) {
1954 assert(sscreen->info.has_tmz_support);
1955 set_drm_keys(drm, decrypt);
1956 }
1957
1958 if (dec->dpb_type == DPB_DYNAMIC_TIER_1) {
1959 decode->decode_flags = 1;
1960 dynamic_dpb->dpbArraySize = NUM_VP9_REFS + 1;
1961 dynamic_dpb->dpbLumaPitch = align(decode->width_in_samples, dec->db_alignment);
1962 dynamic_dpb->dpbLumaAlignedHeight = align(decode->height_in_samples, dec->db_alignment);
1963 dynamic_dpb->dpbLumaAlignedSize =
1964 dynamic_dpb->dpbLumaPitch * dynamic_dpb->dpbLumaAlignedHeight;
1965 dynamic_dpb->dpbChromaPitch = dynamic_dpb->dpbLumaPitch >> 1;
1966 dynamic_dpb->dpbChromaAlignedHeight = dynamic_dpb->dpbLumaAlignedHeight >> 1;
1967 dynamic_dpb->dpbChromaAlignedSize =
1968 dynamic_dpb->dpbChromaPitch * dynamic_dpb->dpbChromaAlignedHeight * 2;
1969 dynamic_dpb->dpbReserved0[0] = dec->db_alignment;
1970
1971 if (dec->base.profile == PIPE_VIDEO_PROFILE_VP9_PROFILE2) {
1972 dynamic_dpb->dpbLumaAlignedSize = dynamic_dpb->dpbLumaAlignedSize * 3 / 2;
1973 dynamic_dpb->dpbChromaAlignedSize = dynamic_dpb->dpbChromaAlignedSize * 3 / 2;
1974 }
1975 }
1976
1977 switch (u_reduce_video_profile(picture->profile)) {
1978 case PIPE_VIDEO_FORMAT_MPEG4_AVC: {
1979 rvcn_dec_message_avc_t avc = get_h264_msg(dec, target, (struct pipe_h264_picture_desc *)picture);
1980 memcpy(codec, (void *)&avc, sizeof(rvcn_dec_message_avc_t));
1981 index_codec->message_id = RDECODE_MESSAGE_AVC;
1982 break;
1983 }
1984 case PIPE_VIDEO_FORMAT_HEVC: {
1985 rvcn_dec_message_hevc_t hevc =
1986 get_h265_msg(dec, target, (struct pipe_h265_picture_desc *)picture);
1987
1988 memcpy(codec, (void *)&hevc, sizeof(rvcn_dec_message_hevc_t));
1989 index_codec->message_id = RDECODE_MESSAGE_HEVC;
1990 break;
1991 }
1992 case PIPE_VIDEO_FORMAT_VC1: {
1993 rvcn_dec_message_vc1_t vc1 = get_vc1_msg((struct pipe_vc1_picture_desc *)picture);
1994
1995 memcpy(codec, (void *)&vc1, sizeof(rvcn_dec_message_vc1_t));
1996 if ((picture->profile == PIPE_VIDEO_PROFILE_VC1_SIMPLE) ||
1997 (picture->profile == PIPE_VIDEO_PROFILE_VC1_MAIN)) {
1998 decode->width_in_samples = align(decode->width_in_samples, 16) / 16;
1999 decode->height_in_samples = align(decode->height_in_samples, 16) / 16;
2000 }
2001 index_codec->message_id = RDECODE_MESSAGE_VC1;
2002 break;
2003 }
2004 case PIPE_VIDEO_FORMAT_MPEG12: {
2005 rvcn_dec_message_mpeg2_vld_t mpeg2 =
2006 get_mpeg2_msg(dec, (struct pipe_mpeg12_picture_desc *)picture);
2007
2008 memcpy(codec, (void *)&mpeg2, sizeof(rvcn_dec_message_mpeg2_vld_t));
2009 index_codec->message_id = RDECODE_MESSAGE_MPEG2_VLD;
2010 break;
2011 }
2012 case PIPE_VIDEO_FORMAT_MPEG4: {
2013 rvcn_dec_message_mpeg4_asp_vld_t mpeg4 =
2014 get_mpeg4_msg(dec, (struct pipe_mpeg4_picture_desc *)picture);
2015
2016 memcpy(codec, (void *)&mpeg4, sizeof(rvcn_dec_message_mpeg4_asp_vld_t));
2017 index_codec->message_id = RDECODE_MESSAGE_MPEG4_ASP_VLD;
2018 break;
2019 }
2020 case PIPE_VIDEO_FORMAT_VP9: {
2021 rvcn_dec_message_vp9_t vp9 =
2022 get_vp9_msg(dec, target, (struct pipe_vp9_picture_desc *)picture);
2023
2024 memcpy(codec, (void *)&vp9, sizeof(rvcn_dec_message_vp9_t));
2025 index_codec->message_id = RDECODE_MESSAGE_VP9;
2026 break;
2027 }
2028 case PIPE_VIDEO_FORMAT_AV1: {
2029 rvcn_dec_message_av1_t av1 =
2030 get_av1_msg(dec, target, (struct pipe_av1_picture_desc *)picture);
2031
2032 memcpy(codec, (void *)&av1, sizeof(rvcn_dec_message_av1_t));
2033 index_codec->message_id = RDECODE_MESSAGE_AV1;
2034
2035 if (dec->ctx.res == NULL) {
2036 unsigned frame_ctxt_size = dec->av1_version == RDECODE_AV1_VER_0
2037 ? align(sizeof(rvcn_av1_frame_context_t), 2048)
2038 : align(sizeof(rvcn_av1_vcn4_frame_context_t), 2048);
2039
2040 unsigned ctx_size = (9 + 4) * frame_ctxt_size + 9 * 64 * 34 * 512 + 9 * 64 * 34 * 256 * 5;
2041 int num_64x64_CTB_8k = 68;
2042 int num_128x128_CTB_8k = 34;
2043 int sdb_pitch_64x64 = align(32 * num_64x64_CTB_8k, 256) * 2;
2044 int sdb_pitch_128x128 = align(32 * num_128x128_CTB_8k, 256) * 2;
2045 int sdb_lf_size_ctb_64x64 = sdb_pitch_64x64 * (align(1728, 64) / 64);
2046 int sdb_lf_size_ctb_128x128 = sdb_pitch_128x128 * (align(3008, 64) / 64);
2047 int sdb_superres_size_ctb_64x64 = sdb_pitch_64x64 * (align(3232, 64) / 64);
2048 int sdb_superres_size_ctb_128x128 = sdb_pitch_128x128 * (align(6208, 64) / 64);
2049 int sdb_output_size_ctb_64x64 = sdb_pitch_64x64 * (align(1312, 64) / 64);
2050 int sdb_output_size_ctb_128x128 = sdb_pitch_128x128 * (align(2336, 64) / 64);
2051 int sdb_fg_avg_luma_size_ctb_64x64 = sdb_pitch_64x64 * (align(384, 64) / 64);
2052 int sdb_fg_avg_luma_size_ctb_128x128 = sdb_pitch_128x128 * (align(640, 64) / 64);
2053 uint8_t *ptr;
2054 int i;
2055 struct rvcn_av1_prob_funcs prob;
2056
2057 if (dec->av1_version == RDECODE_AV1_VER_0) {
2058 prob.init_mode_probs = rvcn_init_mode_probs;
2059 prob.init_mv_probs = rvcn_av1_init_mv_probs;
2060 prob.default_coef_probs = rvcn_av1_default_coef_probs;
2061 } else {
2062 prob.init_mode_probs = rvcn_vcn4_init_mode_probs;
2063 prob.init_mv_probs = rvcn_vcn4_av1_init_mv_probs;
2064 prob.default_coef_probs = rvcn_vcn4_av1_default_coef_probs;
2065 }
2066
2067 ctx_size += (MAX2(sdb_lf_size_ctb_64x64, sdb_lf_size_ctb_128x128) +
2068 MAX2(sdb_superres_size_ctb_64x64, sdb_superres_size_ctb_128x128) +
2069 MAX2(sdb_output_size_ctb_64x64, sdb_output_size_ctb_128x128) +
2070 MAX2(sdb_fg_avg_luma_size_ctb_64x64, sdb_fg_avg_luma_size_ctb_128x128)) * 2 + 68 * 512;
2071
2072 if (!si_vid_create_buffer(dec->screen, &dec->ctx, ctx_size, PIPE_USAGE_DEFAULT))
2073 RVID_ERR("Can't allocated context buffer.\n");
2074 si_vid_clear_buffer(dec->base.context, &dec->ctx);
2075
2076 ptr = dec->ws->buffer_map(dec->ws, dec->ctx.res->buf, &dec->cs, PIPE_MAP_WRITE | RADEON_MAP_TEMPORARY);
2077
2078 for (i = 0; i < 4; ++i) {
2079 prob.init_mode_probs((void*)(ptr + i * frame_ctxt_size));
2080 prob.init_mv_probs((void*)(ptr + i * frame_ctxt_size));
2081 prob.default_coef_probs((void*)(ptr + i * frame_ctxt_size), i);
2082 }
2083 dec->ws->buffer_unmap(dec->ws, dec->ctx.res->buf);
2084 }
2085
2086 break;
2087 }
2088 default:
2089 assert(0);
2090 return NULL;
2091 }
2092
2093 if (dec->ctx.res)
2094 decode->hw_ctxt_size = dec->ctx.res->buf->size;
2095
2096 if (dec->dpb_type == DPB_DYNAMIC_TIER_2)
2097 if (rvcn_dec_dynamic_dpb_t2_message(dec, decode, dynamic_dpb_t2, encrypted))
2098 return NULL;
2099
2100 return luma->buffer.buf;
2101 }
2102
rvcn_dec_message_destroy(struct radeon_decoder *dec)2103 static void rvcn_dec_message_destroy(struct radeon_decoder *dec)
2104 {
2105 rvcn_dec_message_header_t *header = dec->msg;
2106
2107 memset(dec->msg, 0, sizeof(rvcn_dec_message_header_t));
2108 header->header_size = sizeof(rvcn_dec_message_header_t);
2109 header->total_size = sizeof(rvcn_dec_message_header_t) - sizeof(rvcn_dec_message_index_t);
2110 header->num_buffers = 0;
2111 header->msg_type = RDECODE_MSG_DESTROY;
2112 header->stream_handle = dec->stream_handle;
2113 header->status_report_feedback_number = 0;
2114 }
2115
rvcn_dec_message_feedback(struct radeon_decoder *dec)2116 static void rvcn_dec_message_feedback(struct radeon_decoder *dec)
2117 {
2118 rvcn_dec_feedback_header_t *header = (void *)dec->fb;
2119
2120 header->header_size = sizeof(rvcn_dec_feedback_header_t);
2121 header->total_size = sizeof(rvcn_dec_feedback_header_t);
2122 header->num_buffers = 0;
2123 }
2124
rvcn_dec_sq_tail(struct radeon_decoder *dec)2125 static void rvcn_dec_sq_tail(struct radeon_decoder *dec)
2126 {
2127 if (dec->vcn_dec_sw_ring == false)
2128 return;
2129
2130 rvcn_sq_tail(&dec->cs, &dec->sq);
2131 }
2132 /* flush IB to the hardware */
flush(struct radeon_decoder *dec, unsigned flags)2133 static int flush(struct radeon_decoder *dec, unsigned flags)
2134 {
2135 rvcn_dec_sq_tail(dec);
2136
2137 return dec->ws->cs_flush(&dec->cs, flags, NULL);
2138 }
2139
2140 /* add a new set register command to the IB */
set_reg(struct radeon_decoder *dec, unsigned reg, uint32_t val)2141 static void set_reg(struct radeon_decoder *dec, unsigned reg, uint32_t val)
2142 {
2143 radeon_emit(&dec->cs, RDECODE_PKT0(reg >> 2, 0));
2144 radeon_emit(&dec->cs, val);
2145 }
2146
2147 /* send a command to the VCPU through the GPCOM registers */
send_cmd(struct radeon_decoder *dec, unsigned cmd, struct pb_buffer *buf, uint32_t off, unsigned usage, enum radeon_bo_domain domain)2148 static void send_cmd(struct radeon_decoder *dec, unsigned cmd, struct pb_buffer *buf, uint32_t off,
2149 unsigned usage, enum radeon_bo_domain domain)
2150 {
2151 uint64_t addr;
2152
2153 dec->ws->cs_add_buffer(&dec->cs, buf, usage | RADEON_USAGE_SYNCHRONIZED, domain);
2154 addr = dec->ws->buffer_get_virtual_address(buf);
2155 addr = addr + off;
2156
2157 if (dec->vcn_dec_sw_ring == false) {
2158 set_reg(dec, dec->reg.data0, addr);
2159 set_reg(dec, dec->reg.data1, addr >> 32);
2160 set_reg(dec, dec->reg.cmd, cmd << 1);
2161 return;
2162 }
2163
2164 if (!dec->cs.current.cdw) {
2165 rvcn_sq_header(&dec->cs, &dec->sq, false);
2166 rvcn_decode_ib_package_t *ib_header =
2167 (rvcn_decode_ib_package_t *)&(dec->cs.current.buf[dec->cs.current.cdw]);
2168
2169 ib_header->package_size = sizeof(struct rvcn_decode_buffer_s) +
2170 sizeof(struct rvcn_decode_ib_package_s);
2171 dec->cs.current.cdw++;
2172 ib_header->package_type = (RDECODE_IB_PARAM_DECODE_BUFFER);
2173 dec->cs.current.cdw++;
2174
2175 dec->decode_buffer =
2176 (rvcn_decode_buffer_t *)&(dec->cs.current.buf[dec->cs.current.cdw]);
2177
2178 dec->cs.current.cdw += sizeof(struct rvcn_decode_buffer_s) / 4;
2179 memset(dec->decode_buffer, 0, sizeof(struct rvcn_decode_buffer_s));
2180 }
2181
2182 switch(cmd) {
2183 case RDECODE_CMD_MSG_BUFFER:
2184 dec->decode_buffer->valid_buf_flag |= RDECODE_CMDBUF_FLAGS_MSG_BUFFER;
2185 dec->decode_buffer->msg_buffer_address_hi = (addr >> 32);
2186 dec->decode_buffer->msg_buffer_address_lo = (addr);
2187 break;
2188 case RDECODE_CMD_DPB_BUFFER:
2189 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_DPB_BUFFER);
2190 dec->decode_buffer->dpb_buffer_address_hi = (addr >> 32);
2191 dec->decode_buffer->dpb_buffer_address_lo = (addr);
2192 break;
2193 case RDECODE_CMD_DECODING_TARGET_BUFFER:
2194 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_DECODING_TARGET_BUFFER);
2195 dec->decode_buffer->target_buffer_address_hi = (addr >> 32);
2196 dec->decode_buffer->target_buffer_address_lo = (addr);
2197 break;
2198 case RDECODE_CMD_FEEDBACK_BUFFER:
2199 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_FEEDBACK_BUFFER);
2200 dec->decode_buffer->feedback_buffer_address_hi = (addr >> 32);
2201 dec->decode_buffer->feedback_buffer_address_lo = (addr);
2202 break;
2203 case RDECODE_CMD_PROB_TBL_BUFFER:
2204 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_PROB_TBL_BUFFER);
2205 dec->decode_buffer->prob_tbl_buffer_address_hi = (addr >> 32);
2206 dec->decode_buffer->prob_tbl_buffer_address_lo = (addr);
2207 break;
2208 case RDECODE_CMD_SESSION_CONTEXT_BUFFER:
2209 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_SESSION_CONTEXT_BUFFER);
2210 dec->decode_buffer->session_contex_buffer_address_hi = (addr >> 32);
2211 dec->decode_buffer->session_contex_buffer_address_lo = (addr);
2212 break;
2213 case RDECODE_CMD_BITSTREAM_BUFFER:
2214 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_BITSTREAM_BUFFER);
2215 dec->decode_buffer->bitstream_buffer_address_hi = (addr >> 32);
2216 dec->decode_buffer->bitstream_buffer_address_lo = (addr);
2217 break;
2218 case RDECODE_CMD_IT_SCALING_TABLE_BUFFER:
2219 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_IT_SCALING_BUFFER);
2220 dec->decode_buffer->it_sclr_table_buffer_address_hi = (addr >> 32);
2221 dec->decode_buffer->it_sclr_table_buffer_address_lo = (addr);
2222 break;
2223 case RDECODE_CMD_CONTEXT_BUFFER:
2224 dec->decode_buffer->valid_buf_flag |= (RDECODE_CMDBUF_FLAGS_CONTEXT_BUFFER);
2225 dec->decode_buffer->context_buffer_address_hi = (addr >> 32);
2226 dec->decode_buffer->context_buffer_address_lo = (addr);
2227 break;
2228 default:
2229 printf("Not Support!");
2230 }
2231 }
2232
2233 /* do the codec needs an IT buffer ?*/
have_it(struct radeon_decoder *dec)2234 static bool have_it(struct radeon_decoder *dec)
2235 {
2236 return dec->stream_type == RDECODE_CODEC_H264_PERF || dec->stream_type == RDECODE_CODEC_H265;
2237 }
2238
2239 /* do the codec needs an probs buffer? */
have_probs(struct radeon_decoder *dec)2240 static bool have_probs(struct radeon_decoder *dec)
2241 {
2242 return (dec->stream_type == RDECODE_CODEC_VP9 || dec->stream_type == RDECODE_CODEC_AV1);
2243 }
2244
2245 /* map the next available message/feedback/itscaling buffer */
map_msg_fb_it_probs_buf(struct radeon_decoder *dec)2246 static void map_msg_fb_it_probs_buf(struct radeon_decoder *dec)
2247 {
2248 struct rvid_buffer *buf;
2249 uint8_t *ptr;
2250
2251 /* grab the current message/feedback buffer */
2252 buf = &dec->msg_fb_it_probs_buffers[dec->cur_buffer];
2253
2254 /* and map it for CPU access */
2255 ptr =
2256 dec->ws->buffer_map(dec->ws, buf->res->buf, &dec->cs, PIPE_MAP_WRITE | RADEON_MAP_TEMPORARY);
2257
2258 /* calc buffer offsets */
2259 dec->msg = ptr;
2260
2261 dec->fb = (uint32_t *)(ptr + FB_BUFFER_OFFSET);
2262 if (have_it(dec))
2263 dec->it = (uint8_t *)(ptr + FB_BUFFER_OFFSET + FB_BUFFER_SIZE);
2264 else if (have_probs(dec))
2265 dec->probs = (uint8_t *)(ptr + FB_BUFFER_OFFSET + FB_BUFFER_SIZE);
2266 }
2267
2268 /* unmap and send a message command to the VCPU */
send_msg_buf(struct radeon_decoder *dec)2269 static void send_msg_buf(struct radeon_decoder *dec)
2270 {
2271 struct rvid_buffer *buf;
2272
2273 /* ignore the request if message/feedback buffer isn't mapped */
2274 if (!dec->msg || !dec->fb)
2275 return;
2276
2277 /* grab the current message buffer */
2278 buf = &dec->msg_fb_it_probs_buffers[dec->cur_buffer];
2279
2280 /* unmap the buffer */
2281 dec->ws->buffer_unmap(dec->ws, buf->res->buf);
2282 dec->bs_ptr = NULL;
2283 dec->msg = NULL;
2284 dec->fb = NULL;
2285 dec->it = NULL;
2286 dec->probs = NULL;
2287
2288 if (dec->sessionctx.res)
2289 send_cmd(dec, RDECODE_CMD_SESSION_CONTEXT_BUFFER, dec->sessionctx.res->buf, 0,
2290 RADEON_USAGE_READWRITE, RADEON_DOMAIN_VRAM);
2291
2292 /* and send it to the hardware */
2293 send_cmd(dec, RDECODE_CMD_MSG_BUFFER, buf->res->buf, 0, RADEON_USAGE_READ, RADEON_DOMAIN_GTT);
2294 }
2295
2296 /* cycle to the next set of buffers */
next_buffer(struct radeon_decoder *dec)2297 static void next_buffer(struct radeon_decoder *dec)
2298 {
2299 ++dec->cur_buffer;
2300 dec->cur_buffer %= NUM_BUFFERS;
2301 }
2302
calc_ctx_size_h264_perf(struct radeon_decoder *dec)2303 static unsigned calc_ctx_size_h264_perf(struct radeon_decoder *dec)
2304 {
2305 unsigned width_in_mb, height_in_mb, ctx_size;
2306 unsigned width = align(dec->base.width, VL_MACROBLOCK_WIDTH);
2307 unsigned height = align(dec->base.height, VL_MACROBLOCK_HEIGHT);
2308
2309 unsigned max_references = dec->base.max_references + 1;
2310
2311 // picture width & height in 16 pixel units
2312 width_in_mb = width / VL_MACROBLOCK_WIDTH;
2313 height_in_mb = align(height / VL_MACROBLOCK_HEIGHT, 2);
2314
2315 unsigned fs_in_mb = width_in_mb * height_in_mb;
2316 unsigned num_dpb_buffer;
2317 switch (dec->base.level) {
2318 case 30:
2319 num_dpb_buffer = 8100 / fs_in_mb;
2320 break;
2321 case 31:
2322 num_dpb_buffer = 18000 / fs_in_mb;
2323 break;
2324 case 32:
2325 num_dpb_buffer = 20480 / fs_in_mb;
2326 break;
2327 case 41:
2328 num_dpb_buffer = 32768 / fs_in_mb;
2329 break;
2330 case 42:
2331 num_dpb_buffer = 34816 / fs_in_mb;
2332 break;
2333 case 50:
2334 num_dpb_buffer = 110400 / fs_in_mb;
2335 break;
2336 case 51:
2337 num_dpb_buffer = 184320 / fs_in_mb;
2338 break;
2339 default:
2340 num_dpb_buffer = 184320 / fs_in_mb;
2341 break;
2342 }
2343 num_dpb_buffer++;
2344 max_references = MAX2(MIN2(NUM_H264_REFS, num_dpb_buffer), max_references);
2345 ctx_size = max_references * align(width_in_mb * height_in_mb * 192, 256);
2346
2347 return ctx_size;
2348 }
2349
2350 /* calculate size of reference picture buffer */
calc_dpb_size(struct radeon_decoder *dec)2351 static unsigned calc_dpb_size(struct radeon_decoder *dec)
2352 {
2353 unsigned width_in_mb, height_in_mb, image_size, dpb_size;
2354
2355 // always align them to MB size for dpb calculation
2356 unsigned width = align(dec->base.width, VL_MACROBLOCK_WIDTH);
2357 unsigned height = align(dec->base.height, VL_MACROBLOCK_HEIGHT);
2358
2359 // always one more for currently decoded picture
2360 unsigned max_references = dec->base.max_references + 1;
2361
2362 // aligned size of a single frame
2363 image_size = align(width, 32) * height;
2364 image_size += image_size / 2;
2365 image_size = align(image_size, 1024);
2366
2367 // picture width & height in 16 pixel units
2368 width_in_mb = width / VL_MACROBLOCK_WIDTH;
2369 height_in_mb = align(height / VL_MACROBLOCK_HEIGHT, 2);
2370
2371 switch (u_reduce_video_profile(dec->base.profile)) {
2372 case PIPE_VIDEO_FORMAT_MPEG4_AVC: {
2373 unsigned fs_in_mb = width_in_mb * height_in_mb;
2374 unsigned num_dpb_buffer;
2375
2376 switch (dec->base.level) {
2377 case 30:
2378 num_dpb_buffer = 8100 / fs_in_mb;
2379 break;
2380 case 31:
2381 num_dpb_buffer = 18000 / fs_in_mb;
2382 break;
2383 case 32:
2384 num_dpb_buffer = 20480 / fs_in_mb;
2385 break;
2386 case 41:
2387 num_dpb_buffer = 32768 / fs_in_mb;
2388 break;
2389 case 42:
2390 num_dpb_buffer = 34816 / fs_in_mb;
2391 break;
2392 case 50:
2393 num_dpb_buffer = 110400 / fs_in_mb;
2394 break;
2395 case 51:
2396 num_dpb_buffer = 184320 / fs_in_mb;
2397 break;
2398 default:
2399 num_dpb_buffer = 184320 / fs_in_mb;
2400 break;
2401 }
2402 num_dpb_buffer++;
2403 max_references = MAX2(MIN2(NUM_H264_REFS, num_dpb_buffer), max_references);
2404 dpb_size = image_size * max_references;
2405 break;
2406 }
2407
2408 case PIPE_VIDEO_FORMAT_HEVC:
2409 if (dec->base.width * dec->base.height >= 4096 * 2000)
2410 max_references = MAX2(max_references, 8);
2411 else
2412 max_references = MAX2(max_references, 17);
2413
2414 width = align(width, 16);
2415 height = align(height, 16);
2416 if (dec->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10)
2417 dpb_size = align((align(width, 64) * align(height, 64) * 9) / 4, 256) * max_references;
2418 else
2419 dpb_size = align((align(width, 32) * height * 3) / 2, 256) * max_references;
2420 break;
2421
2422 case PIPE_VIDEO_FORMAT_VC1:
2423 // the firmware seems to allways assume a minimum of ref frames
2424 max_references = MAX2(NUM_VC1_REFS, max_references);
2425
2426 // reference picture buffer
2427 dpb_size = image_size * max_references;
2428
2429 // CONTEXT_BUFFER
2430 dpb_size += width_in_mb * height_in_mb * 128;
2431
2432 // IT surface buffer
2433 dpb_size += width_in_mb * 64;
2434
2435 // DB surface buffer
2436 dpb_size += width_in_mb * 128;
2437
2438 // BP
2439 dpb_size += align(MAX2(width_in_mb, height_in_mb) * 7 * 16, 64);
2440 break;
2441
2442 case PIPE_VIDEO_FORMAT_MPEG12:
2443 // reference picture buffer, must be big enough for all frames
2444 dpb_size = image_size * NUM_MPEG2_REFS;
2445 break;
2446
2447 case PIPE_VIDEO_FORMAT_MPEG4:
2448 // reference picture buffer
2449 dpb_size = image_size * max_references;
2450
2451 // CM
2452 dpb_size += width_in_mb * height_in_mb * 64;
2453
2454 // IT surface buffer
2455 dpb_size += align(width_in_mb * height_in_mb * 32, 64);
2456
2457 dpb_size = MAX2(dpb_size, 30 * 1024 * 1024);
2458 break;
2459
2460 case PIPE_VIDEO_FORMAT_VP9:
2461 max_references = MAX2(max_references, 9);
2462
2463 if (dec->dpb_type == DPB_MAX_RES)
2464 dpb_size = (((struct si_screen *)dec->screen)->info.family >= CHIP_RENOIR)
2465 ? (8192 * 4320 * 3 / 2) * max_references
2466 : (4096 * 3000 * 3 / 2) * max_references;
2467 else
2468 dpb_size = (align(dec->base.width, dec->db_alignment) *
2469 align(dec->base.height, dec->db_alignment) * 3 / 2) * max_references;
2470
2471 if (dec->base.profile == PIPE_VIDEO_PROFILE_VP9_PROFILE2)
2472 dpb_size = dpb_size * 3 / 2;
2473 break;
2474
2475 case PIPE_VIDEO_FORMAT_AV1:
2476 max_references = MAX2(max_references, 9);
2477 dpb_size = 8192 * 4320 * 3 / 2 * max_references * 3 / 2;
2478 break;
2479
2480 case PIPE_VIDEO_FORMAT_JPEG:
2481 dpb_size = 0;
2482 break;
2483
2484 default:
2485 // something is missing here
2486 assert(0);
2487
2488 // at least use a sane default value
2489 dpb_size = 32 * 1024 * 1024;
2490 break;
2491 }
2492 return dpb_size;
2493 }
2494
2495 /**
2496 * destroy this video decoder
2497 */
radeon_dec_destroy(struct pipe_video_codec *decoder)2498 static void radeon_dec_destroy(struct pipe_video_codec *decoder)
2499 {
2500 struct radeon_decoder *dec = (struct radeon_decoder *)decoder;
2501 unsigned i;
2502
2503 assert(decoder);
2504
2505 if (dec->stream_type != RDECODE_CODEC_JPEG) {
2506 map_msg_fb_it_probs_buf(dec);
2507 rvcn_dec_message_destroy(dec);
2508 send_msg_buf(dec);
2509 flush(dec, 0);
2510 }
2511
2512 dec->ws->cs_destroy(&dec->cs);
2513
2514 if (dec->stream_type == RDECODE_CODEC_JPEG) {
2515 for (i = 0; i < dec->njctx; i++) {
2516 dec->ws->cs_destroy(&dec->jcs[i]);
2517 dec->ws->ctx_destroy(dec->jctx[i]);
2518 }
2519 }
2520
2521 for (i = 0; i < NUM_BUFFERS; ++i) {
2522 si_vid_destroy_buffer(&dec->msg_fb_it_probs_buffers[i]);
2523 si_vid_destroy_buffer(&dec->bs_buffers[i]);
2524 }
2525
2526 if (dec->dpb_type != DPB_DYNAMIC_TIER_2) {
2527 si_vid_destroy_buffer(&dec->dpb);
2528 } else {
2529 list_for_each_entry_safe(struct rvcn_dec_dynamic_dpb_t2, d, &dec->dpb_ref_list, list) {
2530 list_del(&d->list);
2531 si_vid_destroy_buffer(&d->dpb);
2532 FREE(d);
2533 }
2534 }
2535 si_vid_destroy_buffer(&dec->ctx);
2536 si_vid_destroy_buffer(&dec->sessionctx);
2537
2538 FREE(dec->jcs);
2539 FREE(dec->jctx);
2540 FREE(dec);
2541 }
2542
2543 /**
2544 * start decoding of a new frame
2545 */
radeon_dec_begin_frame(struct pipe_video_codec *decoder, struct pipe_video_buffer *target, struct pipe_picture_desc *picture)2546 static void radeon_dec_begin_frame(struct pipe_video_codec *decoder,
2547 struct pipe_video_buffer *target,
2548 struct pipe_picture_desc *picture)
2549 {
2550 struct radeon_decoder *dec = (struct radeon_decoder *)decoder;
2551 uintptr_t frame;
2552
2553 assert(decoder);
2554
2555 frame = ++dec->frame_number;
2556 if (dec->stream_type != RDECODE_CODEC_VP9 && dec->stream_type != RDECODE_CODEC_AV1
2557 && dec->stream_type != RDECODE_CODEC_H264_PERF)
2558 vl_video_buffer_set_associated_data(target, decoder, (void *)frame,
2559 &radeon_dec_destroy_associated_data);
2560
2561 dec->bs_size = 0;
2562 dec->bs_ptr = dec->ws->buffer_map(dec->ws, dec->bs_buffers[dec->cur_buffer].res->buf, &dec->cs,
2563 PIPE_MAP_WRITE | RADEON_MAP_TEMPORARY);
2564 }
2565
2566 /**
2567 * decode a macroblock
2568 */
radeon_dec_decode_macroblock(struct pipe_video_codec *decoder, struct pipe_video_buffer *target, struct pipe_picture_desc *picture, const struct pipe_macroblock *macroblocks, unsigned num_macroblocks)2569 static void radeon_dec_decode_macroblock(struct pipe_video_codec *decoder,
2570 struct pipe_video_buffer *target,
2571 struct pipe_picture_desc *picture,
2572 const struct pipe_macroblock *macroblocks,
2573 unsigned num_macroblocks)
2574 {
2575 /* not supported (yet) */
2576 assert(0);
2577 }
2578
2579 /**
2580 * decode a bitstream
2581 */
radeon_dec_decode_bitstream(struct pipe_video_codec *decoder, struct pipe_video_buffer *target, struct pipe_picture_desc *picture, unsigned num_buffers, const void *const *buffers, const unsigned *sizes)2582 static void radeon_dec_decode_bitstream(struct pipe_video_codec *decoder,
2583 struct pipe_video_buffer *target,
2584 struct pipe_picture_desc *picture, unsigned num_buffers,
2585 const void *const *buffers, const unsigned *sizes)
2586 {
2587 struct radeon_decoder *dec = (struct radeon_decoder *)decoder;
2588 unsigned i;
2589
2590 assert(decoder);
2591
2592 if (!dec->bs_ptr)
2593 return;
2594
2595 for (i = 0; i < num_buffers; ++i) {
2596 struct rvid_buffer *buf = &dec->bs_buffers[dec->cur_buffer];
2597 unsigned new_size = dec->bs_size + sizes[i];
2598
2599 if (new_size > buf->res->buf->size) {
2600 dec->ws->buffer_unmap(dec->ws, buf->res->buf);
2601 dec->bs_ptr = NULL;
2602 if (!si_vid_resize_buffer(dec->screen, &dec->cs, buf, new_size)) {
2603 RVID_ERR("Can't resize bitstream buffer!");
2604 return;
2605 }
2606
2607 dec->bs_ptr = dec->ws->buffer_map(dec->ws, buf->res->buf, &dec->cs,
2608 PIPE_MAP_WRITE | RADEON_MAP_TEMPORARY);
2609 if (!dec->bs_ptr)
2610 return;
2611
2612 dec->bs_ptr += dec->bs_size;
2613 }
2614
2615 memcpy(dec->bs_ptr, buffers[i], sizes[i]);
2616 dec->bs_size += sizes[i];
2617 dec->bs_ptr += sizes[i];
2618 }
2619 }
2620
2621 /**
2622 * send cmd for vcn dec
2623 */
send_cmd_dec(struct radeon_decoder *dec, struct pipe_video_buffer *target, struct pipe_picture_desc *picture)2624 void send_cmd_dec(struct radeon_decoder *dec, struct pipe_video_buffer *target,
2625 struct pipe_picture_desc *picture)
2626 {
2627 struct pb_buffer *dt;
2628 struct rvid_buffer *msg_fb_it_probs_buf, *bs_buf;
2629
2630 msg_fb_it_probs_buf = &dec->msg_fb_it_probs_buffers[dec->cur_buffer];
2631 bs_buf = &dec->bs_buffers[dec->cur_buffer];
2632
2633 memset(dec->bs_ptr, 0, align(dec->bs_size, 128) - dec->bs_size);
2634 dec->ws->buffer_unmap(dec->ws, bs_buf->res->buf);
2635 dec->bs_ptr = NULL;
2636
2637 map_msg_fb_it_probs_buf(dec);
2638 dt = rvcn_dec_message_decode(dec, target, picture);
2639 rvcn_dec_message_feedback(dec);
2640 send_msg_buf(dec);
2641
2642 if (dec->dpb_type != DPB_DYNAMIC_TIER_2)
2643 send_cmd(dec, RDECODE_CMD_DPB_BUFFER, dec->dpb.res->buf, 0, RADEON_USAGE_READWRITE,
2644 RADEON_DOMAIN_VRAM);
2645 if (dec->ctx.res)
2646 send_cmd(dec, RDECODE_CMD_CONTEXT_BUFFER, dec->ctx.res->buf, 0, RADEON_USAGE_READWRITE,
2647 RADEON_DOMAIN_VRAM);
2648 send_cmd(dec, RDECODE_CMD_BITSTREAM_BUFFER, bs_buf->res->buf, 0, RADEON_USAGE_READ,
2649 RADEON_DOMAIN_GTT);
2650 send_cmd(dec, RDECODE_CMD_DECODING_TARGET_BUFFER, dt, 0, RADEON_USAGE_WRITE, RADEON_DOMAIN_VRAM);
2651 send_cmd(dec, RDECODE_CMD_FEEDBACK_BUFFER, msg_fb_it_probs_buf->res->buf, FB_BUFFER_OFFSET,
2652 RADEON_USAGE_WRITE, RADEON_DOMAIN_GTT);
2653 if (have_it(dec))
2654 send_cmd(dec, RDECODE_CMD_IT_SCALING_TABLE_BUFFER, msg_fb_it_probs_buf->res->buf,
2655 FB_BUFFER_OFFSET + FB_BUFFER_SIZE, RADEON_USAGE_READ, RADEON_DOMAIN_GTT);
2656 else if (have_probs(dec))
2657 send_cmd(dec, RDECODE_CMD_PROB_TBL_BUFFER, msg_fb_it_probs_buf->res->buf,
2658 FB_BUFFER_OFFSET + FB_BUFFER_SIZE, RADEON_USAGE_READ, RADEON_DOMAIN_GTT);
2659
2660 if (dec->vcn_dec_sw_ring == false)
2661 set_reg(dec, dec->reg.cntl, 1);
2662 }
2663
2664 /**
2665 * end decoding of the current frame
2666 */
radeon_dec_end_frame(struct pipe_video_codec *decoder, struct pipe_video_buffer *target, struct pipe_picture_desc *picture)2667 static void radeon_dec_end_frame(struct pipe_video_codec *decoder, struct pipe_video_buffer *target,
2668 struct pipe_picture_desc *picture)
2669 {
2670 struct radeon_decoder *dec = (struct radeon_decoder *)decoder;
2671
2672 assert(decoder);
2673
2674 if (!dec->bs_ptr)
2675 return;
2676
2677 dec->send_cmd(dec, target, picture);
2678 flush(dec, PIPE_FLUSH_ASYNC);
2679 next_buffer(dec);
2680 }
2681
2682 /**
2683 * end decoding of the current jpeg frame
2684 */
radeon_dec_jpeg_end_frame(struct pipe_video_codec *decoder, struct pipe_video_buffer *target, struct pipe_picture_desc *picture)2685 static void radeon_dec_jpeg_end_frame(struct pipe_video_codec *decoder, struct pipe_video_buffer *target,
2686 struct pipe_picture_desc *picture)
2687 {
2688 struct radeon_decoder *dec = (struct radeon_decoder *)decoder;
2689
2690 assert(decoder);
2691
2692 if (!dec->bs_ptr)
2693 return;
2694
2695 dec->send_cmd(dec, target, picture);
2696 dec->ws->cs_flush(&dec->jcs[dec->cb_idx], PIPE_FLUSH_ASYNC, NULL);
2697 next_buffer(dec);
2698 dec->cb_idx = (dec->cb_idx+1) % dec->njctx;
2699 }
2700
2701 /**
2702 * flush any outstanding command buffers to the hardware
2703 */
radeon_dec_flush(struct pipe_video_codec *decoder)2704 static void radeon_dec_flush(struct pipe_video_codec *decoder)
2705 {
2706 }
2707
2708 /**
2709 * create and HW decoder
2710 */
radeon_create_decoder(struct pipe_context *context, const struct pipe_video_codec *templ)2711 struct pipe_video_codec *radeon_create_decoder(struct pipe_context *context,
2712 const struct pipe_video_codec *templ)
2713 {
2714 struct si_context *sctx = (struct si_context *)context;
2715 struct radeon_winsys *ws = sctx->ws;
2716 unsigned width = templ->width, height = templ->height;
2717 unsigned bs_buf_size, stream_type = 0, ring = AMD_IP_VCN_DEC;
2718 struct radeon_decoder *dec;
2719 int r, i;
2720
2721 switch (u_reduce_video_profile(templ->profile)) {
2722 case PIPE_VIDEO_FORMAT_MPEG12:
2723 if (templ->entrypoint > PIPE_VIDEO_ENTRYPOINT_BITSTREAM)
2724 return vl_create_mpeg12_decoder(context, templ);
2725 stream_type = RDECODE_CODEC_MPEG2_VLD;
2726 break;
2727 case PIPE_VIDEO_FORMAT_MPEG4:
2728 width = align(width, VL_MACROBLOCK_WIDTH);
2729 height = align(height, VL_MACROBLOCK_HEIGHT);
2730 stream_type = RDECODE_CODEC_MPEG4;
2731 break;
2732 case PIPE_VIDEO_FORMAT_VC1:
2733 stream_type = RDECODE_CODEC_VC1;
2734 break;
2735 case PIPE_VIDEO_FORMAT_MPEG4_AVC:
2736 width = align(width, VL_MACROBLOCK_WIDTH);
2737 height = align(height, VL_MACROBLOCK_HEIGHT);
2738 stream_type = RDECODE_CODEC_H264_PERF;
2739 break;
2740 case PIPE_VIDEO_FORMAT_HEVC:
2741 stream_type = RDECODE_CODEC_H265;
2742 break;
2743 case PIPE_VIDEO_FORMAT_VP9:
2744 stream_type = RDECODE_CODEC_VP9;
2745 break;
2746 case PIPE_VIDEO_FORMAT_AV1:
2747 stream_type = RDECODE_CODEC_AV1;
2748 break;
2749 case PIPE_VIDEO_FORMAT_JPEG:
2750 stream_type = RDECODE_CODEC_JPEG;
2751 ring = AMD_IP_VCN_JPEG;
2752 break;
2753 default:
2754 assert(0);
2755 break;
2756 }
2757
2758 dec = CALLOC_STRUCT(radeon_decoder);
2759
2760 if (!dec)
2761 return NULL;
2762
2763 dec->base = *templ;
2764 dec->base.context = context;
2765 dec->base.width = width;
2766 dec->base.height = height;
2767
2768 dec->base.destroy = radeon_dec_destroy;
2769 dec->base.begin_frame = radeon_dec_begin_frame;
2770 dec->base.decode_macroblock = radeon_dec_decode_macroblock;
2771 dec->base.decode_bitstream = radeon_dec_decode_bitstream;
2772 dec->base.end_frame = radeon_dec_end_frame;
2773 dec->base.flush = radeon_dec_flush;
2774
2775 dec->stream_type = stream_type;
2776 dec->stream_handle = si_vid_alloc_stream_handle();
2777 dec->screen = context->screen;
2778 dec->ws = ws;
2779
2780 if (u_reduce_video_profile(templ->profile) != PIPE_VIDEO_FORMAT_JPEG &&
2781 sctx->gfx_level >= GFX11) {
2782 dec->vcn_dec_sw_ring = true;
2783 ring = AMD_IP_VCN_UNIFIED;
2784 }
2785
2786 dec->sq.ib_total_size_in_dw = NULL;
2787 dec->sq.ib_checksum = NULL;
2788
2789 if (!ws->cs_create(&dec->cs, sctx->ctx, ring, NULL, NULL, false)) {
2790 RVID_ERR("Can't get command submission context.\n");
2791 goto error;
2792 }
2793
2794 if (dec->stream_type == RDECODE_CODEC_JPEG) {
2795
2796 if (sctx->family == CHIP_ARCTURUS || sctx->family == CHIP_ALDEBARAN)
2797 dec->njctx = 2;
2798 else
2799 dec->njctx = 1;
2800
2801 dec->jctx = (struct radeon_winsys_ctx **) CALLOC(dec->njctx,
2802 sizeof(struct radeon_winsys_ctx *));
2803 dec->jcs = (struct radeon_cmdbuf *) CALLOC(dec->njctx, sizeof(struct radeon_cmdbuf));
2804 if(!dec->jctx || !dec->jcs)
2805 goto err;
2806 for (i = 0; i < dec->njctx; i++) {
2807 /* Initialize the context handle and the command stream. */
2808 dec->jctx[i] = dec->ws->ctx_create(dec->ws, RADEON_CTX_PRIORITY_MEDIUM);
2809 if (!sctx->ctx)
2810 goto error;
2811 if (!dec->ws->cs_create(&dec->jcs[i], dec->jctx[i], ring, NULL, NULL, false)) {
2812 RVID_ERR("Can't get additional command submission context for mJPEG.\n");
2813 goto error;
2814 }
2815 }
2816 dec->base.end_frame = radeon_dec_jpeg_end_frame;
2817 dec->cb_idx = 0;
2818 }
2819
2820 for (i = 0; i < ARRAY_SIZE(dec->render_pic_list); i++)
2821 dec->render_pic_list[i] = NULL;
2822
2823 if (sctx->family >= CHIP_NAVI21 && (stream_type == RDECODE_CODEC_H264_PERF)) {
2824 for (i = 0; i < ARRAY_SIZE(dec->h264_valid_ref_num); i++)
2825 dec->h264_valid_ref_num[i] = (unsigned) -1;
2826 for (i = 0; i < ARRAY_SIZE(dec->h264_valid_poc_num); i++)
2827 dec->h264_valid_poc_num[i] = (unsigned) -1;
2828 }
2829
2830 bs_buf_size = width * height * (512 / (16 * 16));
2831 for (i = 0; i < NUM_BUFFERS; ++i) {
2832 unsigned msg_fb_it_probs_size = FB_BUFFER_OFFSET + FB_BUFFER_SIZE;
2833 if (have_it(dec))
2834 msg_fb_it_probs_size += IT_SCALING_TABLE_SIZE;
2835 else if (have_probs(dec))
2836 msg_fb_it_probs_size += (dec->stream_type == RDECODE_CODEC_VP9) ?
2837 VP9_PROBS_TABLE_SIZE :
2838 sizeof(rvcn_dec_av1_segment_fg_t);
2839 /* use vram to improve performance, workaround an unknown bug */
2840 if (!si_vid_create_buffer(dec->screen, &dec->msg_fb_it_probs_buffers[i], msg_fb_it_probs_size,
2841 PIPE_USAGE_DEFAULT)) {
2842 RVID_ERR("Can't allocated message buffers.\n");
2843 goto error;
2844 }
2845
2846 if (!si_vid_create_buffer(dec->screen, &dec->bs_buffers[i], bs_buf_size,
2847 PIPE_USAGE_STAGING)) {
2848 RVID_ERR("Can't allocated bitstream buffers.\n");
2849 goto error;
2850 }
2851
2852 si_vid_clear_buffer(context, &dec->msg_fb_it_probs_buffers[i]);
2853 si_vid_clear_buffer(context, &dec->bs_buffers[i]);
2854
2855 if (have_probs(dec) && dec->stream_type == RDECODE_CODEC_VP9) {
2856 struct rvid_buffer *buf;
2857 void *ptr;
2858
2859 buf = &dec->msg_fb_it_probs_buffers[i];
2860 ptr = dec->ws->buffer_map(dec->ws, buf->res->buf, &dec->cs,
2861 PIPE_MAP_WRITE | RADEON_MAP_TEMPORARY);
2862 ptr += FB_BUFFER_OFFSET + FB_BUFFER_SIZE;
2863 fill_probs_table(ptr);
2864 dec->ws->buffer_unmap(dec->ws, buf->res->buf);
2865 dec->bs_ptr = NULL;
2866 }
2867 }
2868
2869 if (sctx->family >= CHIP_NAVI21 &&
2870 (stream_type == RDECODE_CODEC_VP9 ||
2871 stream_type == RDECODE_CODEC_AV1 ||
2872 ((stream_type == RDECODE_CODEC_H265) && templ->expect_chunked_decode) ||
2873 ((stream_type == RDECODE_CODEC_H264_PERF) && templ->expect_chunked_decode)))
2874 dec->dpb_type = DPB_DYNAMIC_TIER_2;
2875 else if (sctx->family <= CHIP_NAVI14 && stream_type == RDECODE_CODEC_VP9)
2876 dec->dpb_type = DPB_DYNAMIC_TIER_1;
2877 else
2878 dec->dpb_type = DPB_MAX_RES;
2879
2880 dec->db_alignment = (((struct si_screen *)dec->screen)->info.family >= CHIP_RENOIR &&
2881 dec->base.width > 32 && (dec->stream_type == RDECODE_CODEC_VP9 ||
2882 dec->stream_type == RDECODE_CODEC_AV1 ||
2883 dec->base.profile == PIPE_VIDEO_PROFILE_HEVC_MAIN_10)) ? 64 : 32;
2884
2885 dec->dpb_size = calc_dpb_size(dec);
2886
2887 if (!si_vid_create_buffer(dec->screen, &dec->sessionctx, RDECODE_SESSION_CONTEXT_SIZE,
2888 PIPE_USAGE_DEFAULT)) {
2889 RVID_ERR("Can't allocated session ctx.\n");
2890 goto error;
2891 }
2892 si_vid_clear_buffer(context, &dec->sessionctx);
2893
2894 dec->addr_gfx_mode = RDECODE_ARRAY_MODE_LINEAR;
2895 dec->av1_version = RDECODE_AV1_VER_0;
2896
2897 switch (sctx->family) {
2898 case CHIP_RAVEN:
2899 case CHIP_RAVEN2:
2900 dec->reg.data0 = RDECODE_VCN1_GPCOM_VCPU_DATA0;
2901 dec->reg.data1 = RDECODE_VCN1_GPCOM_VCPU_DATA1;
2902 dec->reg.cmd = RDECODE_VCN1_GPCOM_VCPU_CMD;
2903 dec->reg.cntl = RDECODE_VCN1_ENGINE_CNTL;
2904 dec->jpg.direct_reg = false;
2905 break;
2906 case CHIP_NAVI10:
2907 case CHIP_NAVI12:
2908 case CHIP_NAVI14:
2909 case CHIP_RENOIR:
2910 dec->reg.data0 = RDECODE_VCN2_GPCOM_VCPU_DATA0;
2911 dec->reg.data1 = RDECODE_VCN2_GPCOM_VCPU_DATA1;
2912 dec->reg.cmd = RDECODE_VCN2_GPCOM_VCPU_CMD;
2913 dec->reg.cntl = RDECODE_VCN2_ENGINE_CNTL;
2914 dec->jpg.direct_reg = true;
2915 break;
2916 case CHIP_ARCTURUS:
2917 case CHIP_ALDEBARAN:
2918 case CHIP_NAVI21:
2919 case CHIP_NAVI22:
2920 case CHIP_NAVI23:
2921 case CHIP_NAVI24:
2922 case CHIP_VANGOGH:
2923 case CHIP_REMBRANDT:
2924 case CHIP_GFX1036:
2925 dec->reg.data0 = RDECODE_VCN2_5_GPCOM_VCPU_DATA0;
2926 dec->reg.data1 = RDECODE_VCN2_5_GPCOM_VCPU_DATA1;
2927 dec->reg.cmd = RDECODE_VCN2_5_GPCOM_VCPU_CMD;
2928 dec->reg.cntl = RDECODE_VCN2_5_ENGINE_CNTL;
2929 dec->jpg.direct_reg = true;
2930 break;
2931 case CHIP_GFX1100:
2932 case CHIP_GFX1102:
2933 dec->jpg.direct_reg = true;
2934 dec->addr_gfx_mode = RDECODE_ARRAY_MODE_ADDRLIB_SEL_GFX11;
2935 dec->av1_version = RDECODE_AV1_VER_1;
2936 break;
2937 default:
2938 RVID_ERR("VCN is not supported.\n");
2939 goto error;
2940 }
2941
2942 if (dec->stream_type != RDECODE_CODEC_JPEG) {
2943 map_msg_fb_it_probs_buf(dec);
2944 rvcn_dec_message_create(dec);
2945 send_msg_buf(dec);
2946 r = flush(dec, 0);
2947 if (r)
2948 goto error;
2949 }
2950
2951 next_buffer(dec);
2952
2953 if (stream_type == RDECODE_CODEC_JPEG)
2954 dec->send_cmd = send_cmd_jpeg;
2955 else
2956 dec->send_cmd = send_cmd_dec;
2957
2958
2959 if (dec->dpb_type == DPB_DYNAMIC_TIER_2) {
2960 list_inithead(&dec->dpb_ref_list);
2961 list_inithead(&dec->dpb_unref_list);
2962 }
2963
2964 dec->tmz_ctx = sctx->family < CHIP_RENOIR;
2965
2966 return &dec->base;
2967
2968 error:
2969 dec->ws->cs_destroy(&dec->cs);
2970
2971 if (dec->stream_type == RDECODE_CODEC_JPEG) {
2972 for (i = 0; i < dec->njctx; i++) {
2973 dec->ws->cs_destroy(&dec->jcs[i]);
2974 dec->ws->ctx_destroy(dec->jctx[i]);
2975 }
2976 }
2977
2978 for (i = 0; i < NUM_BUFFERS; ++i) {
2979 si_vid_destroy_buffer(&dec->msg_fb_it_probs_buffers[i]);
2980 si_vid_destroy_buffer(&dec->bs_buffers[i]);
2981 }
2982
2983 if (dec->dpb_type != DPB_DYNAMIC_TIER_2)
2984 si_vid_destroy_buffer(&dec->dpb);
2985 si_vid_destroy_buffer(&dec->ctx);
2986 si_vid_destroy_buffer(&dec->sessionctx);
2987
2988 err:
2989 if (dec->jcs)
2990 FREE(dec->jcs);
2991 if (dec->jctx)
2992 FREE(dec->jctx);
2993 FREE(dec);
2994
2995 return NULL;
2996 }
2997