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 55static unsigned calc_dpb_size(struct radeon_decoder *dec); 56static unsigned calc_ctx_size_h264_perf(struct radeon_decoder *dec); 57static unsigned calc_ctx_size_h265_main(struct radeon_decoder *dec); 58static unsigned calc_ctx_size_h265_main10(struct radeon_decoder *dec, 59 struct pipe_h265_picture_desc *pic); 60 61static void radeon_dec_destroy_associated_data(void *data) 62{ 63 /* NOOP, since we only use an intptr */ 64} 65 66static 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 287end: 288 return result; 289} 290 291static 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 477static 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 504static 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 698static 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 739static 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 1097static 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 1158static 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 1219static 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 1259static 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 1299static 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 1318static 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 1349static 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 1366static 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 1401static 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 1460static 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 1477static 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 1523static 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 1566static 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 1591static 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 1700static 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 2103static 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 2116static 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 2125static 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 */ 2133static 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 */ 2141static 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 */ 2148static 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 ?*/ 2234static 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? */ 2240static 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 */ 2246static 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 */ 2269static 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 */ 2297static void next_buffer(struct radeon_decoder *dec) 2298{ 2299 ++dec->cur_buffer; 2300 dec->cur_buffer %= NUM_BUFFERS; 2301} 2302 2303static 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 */ 2351static 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 */ 2498static 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 */ 2546static 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 */ 2569static 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 */ 2582static 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 */ 2624void 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 */ 2667static 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 */ 2685static 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 */ 2704static void radeon_dec_flush(struct pipe_video_codec *decoder) 2705{ 2706} 2707 2708/** 2709 * create and HW decoder 2710 */ 2711struct 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 2968error: 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 2988err: 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