| @@ -0,0 +1,657 @@ |
| | 1 | /* |
| | 2 | * VVC HW decode acceleration through VA API |
| | 3 | * |
| | 4 | * Copyright (c) 2024 Intel Corporation |
| | 5 | * |
| | 6 | * This file is part of FFmpeg. |
| | 7 | * |
| | 8 | * FFmpeg is free software; you can redistribute it and/or |
| | 9 | * modify it under the terms of the GNU Lesser General Public |
| | 10 | * License as published by the Free Software Foundation; either |
| | 11 | * version 2.1 of the License, or (at your option) any later version. |
| | 12 | * |
| | 13 | * FFmpeg is distributed in the hope that it will be useful, |
| | 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| | 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| | 16 | * Lesser General Public License for more details. |
| | 17 | * |
| | 18 | * You should have received a copy of the GNU Lesser General Public |
| | 19 | * License along with FFmpeg; if not, write to the Free Software |
| | 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| | 21 | */ |
| | 22 | |
| | 23 | #include <va/va.h> |
| | 24 | #include <va/va_dec_vvc.h> |
| | 25 | |
| | 26 | #include "vvc/dec.h" |
| | 27 | #include "vvc/refs.h" |
| | 28 | #include "hwaccel_internal.h" |
| | 29 | #include "vaapi_decode.h" |
| | 30 | |
| | 31 | typedef struct VAAPIDecodePictureVVC { |
| | 32 | VAAPIDecodePicture pic; |
| | 33 | VAPictureParameterBufferVVC pic_param; |
| | 34 | VASliceParameterBufferVVC slice_param; |
| | 35 | int decode_issued; |
| | 36 | } VAAPIDecodePictureVVC; |
| | 37 | |
| | 38 | static void init_vaapi_pic(VAPictureVVC *va_pic) |
| | 39 | { |
| | 40 | va_pic->picture_id = VA_INVALID_ID; |
| | 41 | va_pic->flags = VA_PICTURE_VVC_INVALID; |
| | 42 | va_pic->pic_order_cnt = 0; |
| | 43 | } |
| | 44 | |
| | 45 | static void fill_vaapi_pic(VAPictureVVC *va_pic, const VVCFrame *pic) |
| | 46 | { |
| | 47 | va_pic->picture_id = ff_vaapi_get_surface_id(pic->frame); |
| | 48 | va_pic->pic_order_cnt = pic->poc; |
| | 49 | va_pic->flags = 0; |
| | 50 | |
| | 51 | if (pic->flags & VVC_FRAME_FLAG_LONG_REF) |
| | 52 | va_pic->flags |= VA_PICTURE_VVC_LONG_TERM_REFERENCE; |
| | 53 | } |
| | 54 | |
| | 55 | static void fill_vaapi_reference_frames(const VVCFrameContext *h, VAPictureParameterBufferVVC *pp) |
| | 56 | { |
| | 57 | const VVCFrame *current_picture = h->ref; |
| | 58 | int i, j; |
| | 59 | |
| | 60 | for (i = 0, j = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) { |
| | 61 | const VVCFrame *frame = NULL; |
| | 62 | |
| | 63 | while (!frame && j < FF_ARRAY_ELEMS(h->DPB)) { |
| | 64 | if ((&h->DPB[j] != current_picture ) && |
| | 65 | (h->DPB[j].flags & (VVC_FRAME_FLAG_LONG_REF | VVC_FRAME_FLAG_SHORT_REF))) |
| | 66 | frame = &h->DPB[j]; |
| | 67 | j++; |
| | 68 | } |
| | 69 | |
| | 70 | init_vaapi_pic(&pp->ReferenceFrames[i]); |
| | 71 | |
| | 72 | if (frame) { |
| | 73 | VAAPIDecodePictureVVC *pic; |
| | 74 | fill_vaapi_pic(&pp->ReferenceFrames[i], frame); |
| | 75 | pic = frame->hwaccel_picture_private; |
| | 76 | if (!pic->decode_issued) |
| | 77 | pp->ReferenceFrames[i].flags |= VA_PICTURE_VVC_UNAVAILABLE_REFERENCE; |
| | 78 | } |
| | 79 | } |
| | 80 | } |
| | 81 | |
| | 82 | static int vaapi_vvc_start_frame(AVCodecContext *avctx, |
| | 83 | av_unused const uint8_t *buffer, |
| | 84 | av_unused uint32_t size) |
| | 85 | { |
| | 86 | const VVCContext *h = avctx->priv_data; |
| | 87 | VVCFrameContext *fc = &h->fcs[(h->nb_frames + h->nb_fcs) % h->nb_fcs]; |
| | 88 | const H266RawSPS *sps = fc->ps.sps->r; |
| | 89 | const H266RawPPS *pps = fc->ps.pps->r; |
| | 90 | const H266RawPictureHeader *ph = fc->ps.ph.r; |
| | 91 | VAAPIDecodePictureVVC *pic = fc->ref->hwaccel_picture_private; |
| | 92 | VAPictureParameterBufferVVC *pic_param = &pic->pic_param; |
| | 93 | uint16_t tile_dim, exp_slice_height_in_ctus[VVC_MAX_SLICES] = {0}; |
| | 94 | int i, j, k, err; |
| | 95 | |
| | 96 | pic->pic.output_surface = ff_vaapi_get_surface_id(fc->ref->frame); |
| | 97 | |
| | 98 | *pic_param = (VAPictureParameterBufferVVC) { |
| | 99 | .pps_pic_width_in_luma_samples = pps->pps_pic_width_in_luma_samples, |
| | 100 | .pps_pic_height_in_luma_samples = pps->pps_pic_height_in_luma_samples, |
| | 101 | .sps_num_subpics_minus1 = sps->sps_num_subpics_minus1, |
| | 102 | .sps_chroma_format_idc = sps->sps_chroma_format_idc, |
| | 103 | .sps_bitdepth_minus8 = sps->sps_bitdepth_minus8, |
| | 104 | .sps_log2_ctu_size_minus5 = sps->sps_log2_ctu_size_minus5, |
| | 105 | .sps_log2_min_luma_coding_block_size_minus2 = sps->sps_log2_min_luma_coding_block_size_minus2, |
| | 106 | .sps_log2_transform_skip_max_size_minus2 = sps->sps_log2_transform_skip_max_size_minus2, |
| | 107 | .sps_six_minus_max_num_merge_cand = sps->sps_six_minus_max_num_merge_cand, |
| | 108 | .sps_five_minus_max_num_subblock_merge_cand = sps->sps_five_minus_max_num_subblock_merge_cand, |
| | 109 | .sps_max_num_merge_cand_minus_max_num_gpm_cand = sps->sps_max_num_merge_cand_minus_max_num_gpm_cand, |
| | 110 | .sps_log2_parallel_merge_level_minus2 = sps->sps_log2_parallel_merge_level_minus2, |
| | 111 | .sps_min_qp_prime_ts = sps->sps_min_qp_prime_ts, |
| | 112 | .sps_six_minus_max_num_ibc_merge_cand = sps->sps_six_minus_max_num_ibc_merge_cand, |
| | 113 | .sps_num_ladf_intervals_minus2 = sps->sps_num_ladf_intervals_minus2, |
| | 114 | .sps_ladf_lowest_interval_qp_offset = sps->sps_ladf_lowest_interval_qp_offset, |
| | 115 | .sps_flags.bits = { |
| | 116 | .sps_subpic_info_present_flag = sps->sps_subpic_info_present_flag, |
| | 117 | .sps_independent_subpics_flag = sps->sps_independent_subpics_flag, |
| | 118 | .sps_subpic_same_size_flag = sps->sps_subpic_same_size_flag, |
| | 119 | .sps_entropy_coding_sync_enabled_flag = sps->sps_entropy_coding_sync_enabled_flag, |
| | 120 | .sps_qtbtt_dual_tree_intra_flag = sps->sps_qtbtt_dual_tree_intra_flag, |
| | 121 | .sps_max_luma_transform_size_64_flag = sps->sps_max_luma_transform_size_64_flag, |
| | 122 | .sps_transform_skip_enabled_flag = sps->sps_transform_skip_enabled_flag, |
| | 123 | .sps_bdpcm_enabled_flag = sps->sps_bdpcm_enabled_flag, |
| | 124 | .sps_mts_enabled_flag = sps->sps_mts_enabled_flag, |
| | 125 | .sps_explicit_mts_intra_enabled_flag = sps->sps_explicit_mts_intra_enabled_flag, |
| | 126 | .sps_explicit_mts_inter_enabled_flag = sps->sps_explicit_mts_inter_enabled_flag, |
| | 127 | .sps_lfnst_enabled_flag = sps->sps_lfnst_enabled_flag, |
| | 128 | .sps_joint_cbcr_enabled_flag = sps->sps_joint_cbcr_enabled_flag, |
| | 129 | .sps_same_qp_table_for_chroma_flag = sps->sps_same_qp_table_for_chroma_flag, |
| | 130 | .sps_sao_enabled_flag = sps->sps_sao_enabled_flag, |
| | 131 | .sps_alf_enabled_flag = sps->sps_alf_enabled_flag, |
| | 132 | .sps_ccalf_enabled_flag = sps->sps_ccalf_enabled_flag, |
| | 133 | .sps_lmcs_enabled_flag = sps->sps_lmcs_enabled_flag, |
| | 134 | .sps_sbtmvp_enabled_flag = sps->sps_sbtmvp_enabled_flag, |
| | 135 | .sps_amvr_enabled_flag = sps->sps_amvr_enabled_flag, |
| | 136 | .sps_smvd_enabled_flag = sps->sps_smvd_enabled_flag, |
| | 137 | .sps_mmvd_enabled_flag = sps->sps_mmvd_enabled_flag, |
| | 138 | .sps_sbt_enabled_flag = sps->sps_sbt_enabled_flag, |
| | 139 | .sps_affine_enabled_flag = sps->sps_affine_enabled_flag, |
| | 140 | .sps_6param_affine_enabled_flag = sps->sps_6param_affine_enabled_flag, |
| | 141 | .sps_affine_amvr_enabled_flag = sps->sps_affine_amvr_enabled_flag, |
| | 142 | .sps_affine_prof_enabled_flag = sps->sps_affine_prof_enabled_flag, |
| | 143 | .sps_bcw_enabled_flag = sps->sps_bcw_enabled_flag, |
| | 144 | .sps_ciip_enabled_flag = sps->sps_ciip_enabled_flag, |
| | 145 | .sps_gpm_enabled_flag = sps->sps_gpm_enabled_flag, |
| | 146 | .sps_isp_enabled_flag = sps->sps_isp_enabled_flag, |
| | 147 | .sps_mrl_enabled_flag = sps->sps_mrl_enabled_flag, |
| | 148 | .sps_mip_enabled_flag = sps->sps_mip_enabled_flag, |
| | 149 | .sps_cclm_enabled_flag = sps->sps_cclm_enabled_flag, |
| | 150 | .sps_chroma_horizontal_collocated_flag = sps->sps_chroma_horizontal_collocated_flag, |
| | 151 | .sps_chroma_vertical_collocated_flag = sps->sps_chroma_vertical_collocated_flag, |
| | 152 | .sps_palette_enabled_flag = sps->sps_palette_enabled_flag, |
| | 153 | .sps_act_enabled_flag = sps->sps_act_enabled_flag, |
| | 154 | .sps_ibc_enabled_flag = sps->sps_ibc_enabled_flag, |
| | 155 | .sps_ladf_enabled_flag = sps->sps_ladf_enabled_flag, |
| | 156 | .sps_explicit_scaling_list_enabled_flag = sps->sps_explicit_scaling_list_enabled_flag, |
| | 157 | .sps_scaling_matrix_for_lfnst_disabled_flag = sps->sps_scaling_matrix_for_lfnst_disabled_flag, |
| | 158 | .sps_scaling_matrix_for_alternative_colour_space_disabled_flag = sps->sps_scaling_matrix_for_alternative_colour_space_disabled_flag, |
| | 159 | .sps_scaling_matrix_designated_colour_space_flag = sps->sps_scaling_matrix_designated_colour_space_flag, |
| | 160 | .sps_virtual_boundaries_enabled_flag = sps->sps_virtual_boundaries_enabled_flag, |
| | 161 | .sps_virtual_boundaries_present_flag = sps->sps_virtual_boundaries_present_flag, |
| | 162 | }, |
| | 163 | .NumVerVirtualBoundaries = sps->sps_virtual_boundaries_present_flag ? |
| | 164 | sps->sps_num_ver_virtual_boundaries : |
| | 165 | ph->ph_num_ver_virtual_boundaries, |
| | 166 | .NumHorVirtualBoundaries = sps->sps_virtual_boundaries_present_flag ? |
| | 167 | sps->sps_num_hor_virtual_boundaries : |
| | 168 | ph->ph_num_hor_virtual_boundaries, |
| | 169 | .pps_scaling_win_left_offset = pps->pps_scaling_win_left_offset, |
| | 170 | .pps_scaling_win_right_offset = pps->pps_scaling_win_right_offset, |
| | 171 | .pps_scaling_win_top_offset = pps->pps_scaling_win_top_offset, |
| | 172 | .pps_scaling_win_bottom_offset = pps->pps_scaling_win_bottom_offset, |
| | 173 | .pps_num_exp_tile_columns_minus1 = pps->pps_num_exp_tile_columns_minus1, |
| | 174 | .pps_num_exp_tile_rows_minus1 = pps->pps_num_exp_tile_rows_minus1, |
| | 175 | .pps_num_slices_in_pic_minus1 = pps->pps_num_slices_in_pic_minus1, |
| | 176 | .pps_pic_width_minus_wraparound_offset = pps->pps_pic_width_minus_wraparound_offset, |
| | 177 | .pps_cb_qp_offset = pps->pps_cb_qp_offset, |
| | 178 | .pps_cr_qp_offset = pps->pps_cr_qp_offset, |
| | 179 | .pps_joint_cbcr_qp_offset_value = pps->pps_joint_cbcr_qp_offset_value, |
| | 180 | .pps_chroma_qp_offset_list_len_minus1 = pps->pps_chroma_qp_offset_list_len_minus1, |
| | 181 | .pps_flags.bits = { |
| | 182 | .pps_loop_filter_across_tiles_enabled_flag = pps->pps_loop_filter_across_tiles_enabled_flag, |
| | 183 | .pps_rect_slice_flag = pps->pps_rect_slice_flag, |
| | 184 | .pps_single_slice_per_subpic_flag = pps->pps_single_slice_per_subpic_flag, |
| | 185 | .pps_loop_filter_across_slices_enabled_flag = pps->pps_loop_filter_across_slices_enabled_flag, |
| | 186 | .pps_weighted_pred_flag = pps->pps_weighted_pred_flag, |
| | 187 | .pps_weighted_bipred_flag = pps->pps_weighted_bipred_flag, |
| | 188 | .pps_ref_wraparound_enabled_flag = pps->pps_ref_wraparound_enabled_flag, |
| | 189 | .pps_cu_qp_delta_enabled_flag = pps->pps_cu_qp_delta_enabled_flag, |
| | 190 | .pps_cu_chroma_qp_offset_list_enabled_flag = pps->pps_cu_chroma_qp_offset_list_enabled_flag, |
| | 191 | .pps_deblocking_filter_override_enabled_flag = pps->pps_deblocking_filter_override_enabled_flag, |
| | 192 | .pps_deblocking_filter_disabled_flag = pps->pps_deblocking_filter_disabled_flag, |
| | 193 | .pps_dbf_info_in_ph_flag = pps->pps_dbf_info_in_ph_flag, |
| | 194 | .pps_sao_info_in_ph_flag = pps->pps_sao_info_in_ph_flag, |
| | 195 | .pps_alf_info_in_ph_flag = pps->pps_alf_info_in_ph_flag, |
| | 196 | }, |
| | 197 | .ph_lmcs_aps_id = ph->ph_lmcs_aps_id, |
| | 198 | .ph_scaling_list_aps_id = ph->ph_scaling_list_aps_id, |
| | 199 | .ph_log2_diff_min_qt_min_cb_intra_slice_luma = ph->ph_log2_diff_min_qt_min_cb_intra_slice_luma, |
| | 200 | .ph_max_mtt_hierarchy_depth_intra_slice_luma = ph->ph_max_mtt_hierarchy_depth_intra_slice_luma, |
| | 201 | .ph_log2_diff_max_bt_min_qt_intra_slice_luma = ph->ph_log2_diff_max_bt_min_qt_intra_slice_luma, |
| | 202 | .ph_log2_diff_max_tt_min_qt_intra_slice_luma = ph->ph_log2_diff_max_tt_min_qt_intra_slice_luma, |
| | 203 | .ph_log2_diff_min_qt_min_cb_intra_slice_chroma = ph->ph_log2_diff_min_qt_min_cb_intra_slice_chroma, |
| | 204 | .ph_max_mtt_hierarchy_depth_intra_slice_chroma = ph->ph_max_mtt_hierarchy_depth_intra_slice_chroma, |
| | 205 | .ph_log2_diff_max_bt_min_qt_intra_slice_chroma = ph->ph_log2_diff_max_bt_min_qt_intra_slice_chroma, |
| | 206 | .ph_log2_diff_max_tt_min_qt_intra_slice_chroma = ph->ph_log2_diff_max_tt_min_qt_intra_slice_chroma, |
| | 207 | .ph_cu_qp_delta_subdiv_intra_slice = ph->ph_cu_qp_delta_subdiv_intra_slice, |
| | 208 | .ph_cu_chroma_qp_offset_subdiv_intra_slice = ph->ph_cu_chroma_qp_offset_subdiv_intra_slice, |
| | 209 | .ph_log2_diff_min_qt_min_cb_inter_slice = ph->ph_log2_diff_min_qt_min_cb_inter_slice, |
| | 210 | .ph_max_mtt_hierarchy_depth_inter_slice = ph->ph_max_mtt_hierarchy_depth_inter_slice, |
| | 211 | .ph_log2_diff_max_bt_min_qt_inter_slice = ph->ph_log2_diff_max_bt_min_qt_inter_slice, |
| | 212 | .ph_log2_diff_max_tt_min_qt_inter_slice = ph->ph_log2_diff_max_tt_min_qt_inter_slice, |
| | 213 | .ph_cu_qp_delta_subdiv_inter_slice = ph->ph_cu_qp_delta_subdiv_inter_slice, |
| | 214 | .ph_cu_chroma_qp_offset_subdiv_inter_slice = ph->ph_cu_chroma_qp_offset_subdiv_inter_slice, |
| | 215 | .ph_flags.bits= { |
| | 216 | .ph_non_ref_pic_flag = ph->ph_non_ref_pic_flag, |
| | 217 | .ph_alf_enabled_flag = ph->ph_alf_enabled_flag, |
| | 218 | .ph_alf_cb_enabled_flag = ph->ph_alf_cb_enabled_flag, |
| | 219 | .ph_alf_cr_enabled_flag = ph->ph_alf_cr_enabled_flag, |
| | 220 | .ph_alf_cc_cb_enabled_flag = ph->ph_alf_cc_cb_enabled_flag, |
| | 221 | .ph_alf_cc_cr_enabled_flag = ph->ph_alf_cc_cr_enabled_flag, |
| | 222 | .ph_lmcs_enabled_flag = ph->ph_lmcs_enabled_flag, |
| | 223 | .ph_chroma_residual_scale_flag = ph->ph_chroma_residual_scale_flag, |
| | 224 | .ph_explicit_scaling_list_enabled_flag = ph->ph_explicit_scaling_list_enabled_flag, |
| | 225 | .ph_virtual_boundaries_present_flag = ph->ph_virtual_boundaries_present_flag, |
| | 226 | .ph_temporal_mvp_enabled_flag = ph->ph_temporal_mvp_enabled_flag, |
| | 227 | .ph_mmvd_fullpel_only_flag = ph->ph_mmvd_fullpel_only_flag, |
| | 228 | .ph_mvd_l1_zero_flag = ph->ph_mvd_l1_zero_flag, |
| | 229 | .ph_bdof_disabled_flag = ph->ph_bdof_disabled_flag, |
| | 230 | .ph_dmvr_disabled_flag = ph->ph_dmvr_disabled_flag, |
| | 231 | .ph_prof_disabled_flag = ph->ph_prof_disabled_flag, |
| | 232 | .ph_joint_cbcr_sign_flag = ph->ph_joint_cbcr_sign_flag, |
| | 233 | .ph_sao_luma_enabled_flag = ph->ph_sao_luma_enabled_flag, |
| | 234 | .ph_sao_chroma_enabled_flag = ph->ph_sao_chroma_enabled_flag, |
| | 235 | .ph_deblocking_filter_disabled_flag = ph->ph_deblocking_filter_disabled_flag, |
| | 236 | }, |
| | 237 | .PicMiscFlags.fields = { |
| | 238 | .IntraPicFlag = pps->pps_mixed_nalu_types_in_pic_flag ? 0 : IS_IRAP(h) ? 1 : 0, |
| | 239 | } |
| | 240 | }; |
| | 241 | |
| | 242 | fill_vaapi_pic(&pic_param->CurrPic, fc->ref); |
| | 243 | fill_vaapi_reference_frames(fc, pic_param); |
| | 244 | |
| | 245 | for (i = 0; i < VVC_MAX_SAMPLE_ARRAYS; i++) |
| | 246 | for (j = 0; j < VVC_MAX_POINTS_IN_QP_TABLE; j++) |
| | 247 | pic_param->ChromaQpTable[i][j] = fc->ps.sps->chroma_qp_table[i][j]; |
| | 248 | for (i = 0; i < 4; i++) { |
| | 249 | pic_param->sps_ladf_qp_offset[i] = sps->sps_ladf_qp_offset[i]; |
| | 250 | pic_param->sps_ladf_delta_threshold_minus1[i] = sps->sps_ladf_delta_threshold_minus1[i]; |
| | 251 | } |
| | 252 | |
| | 253 | for (i = 0; i < (sps->sps_virtual_boundaries_present_flag ? sps->sps_num_ver_virtual_boundaries : ph->ph_num_ver_virtual_boundaries); i++) { |
| | 254 | pic_param->VirtualBoundaryPosX[i] = (sps->sps_virtual_boundaries_present_flag ? |
| | 255 | (sps->sps_virtual_boundary_pos_x_minus1[i] + 1) : |
| | 256 | (ph->ph_virtual_boundary_pos_x_minus1[i] + 1)) * 8; |
| | 257 | } |
| | 258 | |
| | 259 | for (i = 0; i < (sps->sps_virtual_boundaries_present_flag ? sps->sps_num_hor_virtual_boundaries : ph->ph_num_hor_virtual_boundaries); i++) { |
| | 260 | pic_param->VirtualBoundaryPosY[i] = (sps->sps_virtual_boundaries_present_flag ? |
| | 261 | (sps->sps_virtual_boundary_pos_y_minus1[i] + 1) : |
| | 262 | (ph->ph_virtual_boundary_pos_y_minus1[i] + 1)) * 8; |
| | 263 | } |
| | 264 | |
| | 265 | for (i = 0; i < 6; i++) { |
| | 266 | pic_param->pps_cb_qp_offset_list[i] = pps->pps_cb_qp_offset_list[i]; |
| | 267 | pic_param->pps_cr_qp_offset_list[i] = pps->pps_cr_qp_offset_list[i]; |
| | 268 | pic_param->pps_joint_cbcr_qp_offset_list[i] = pps->pps_joint_cbcr_qp_offset_list[i]; |
| | 269 | } |
| | 270 | |
| | 271 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 272 | VAPictureParameterBufferType, |
| | 273 | &pic->pic_param, sizeof(VAPictureParameterBufferVVC)); |
| | 274 | if (err < 0) |
| | 275 | goto fail; |
| | 276 | |
| | 277 | for (i = 0; i <= sps->sps_num_subpics_minus1 && sps->sps_subpic_info_present_flag; i++) { |
| | 278 | VASubPicVVC subpic_param = { |
| | 279 | .sps_subpic_ctu_top_left_x = sps->sps_subpic_ctu_top_left_x[i], |
| | 280 | .sps_subpic_ctu_top_left_y = sps->sps_subpic_ctu_top_left_y[i], |
| | 281 | .sps_subpic_width_minus1 = sps->sps_subpic_width_minus1[i], |
| | 282 | .sps_subpic_height_minus1 = sps->sps_subpic_height_minus1[i], |
| | 283 | .SubpicIdVal = pps->sub_pic_id_val[i], |
| | 284 | .subpic_flags.bits = { |
| | 285 | .sps_subpic_treated_as_pic_flag = sps->sps_subpic_treated_as_pic_flag[i], |
| | 286 | .sps_loop_filter_across_subpic_enabled_flag = sps->sps_loop_filter_across_subpic_enabled_flag[i], |
| | 287 | } |
| | 288 | }; |
| | 289 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 290 | VASubPicBufferType, |
| | 291 | &subpic_param, sizeof(VASubPicVVC)); |
| | 292 | if (err < 0) |
| | 293 | goto fail; |
| | 294 | } |
| | 295 | |
| | 296 | for (i = 0; i < VVC_MAX_ALF_COUNT; i++) { |
| | 297 | const VVCALF *alf_list = h->ps.alf_list[i]; |
| | 298 | if (alf_list) { |
| | 299 | const H266RawAPS *alf = alf_list->r; |
| | 300 | VAAlfDataVVC alf_param = { |
| | 301 | .aps_adaptation_parameter_set_id = i, |
| | 302 | .alf_luma_num_filters_signalled_minus1 = alf->alf_luma_num_filters_signalled_minus1, |
| | 303 | .alf_chroma_num_alt_filters_minus1 = alf->alf_chroma_num_alt_filters_minus1, |
| | 304 | .alf_cc_cb_filters_signalled_minus1 = alf->alf_cc_cb_filters_signalled_minus1, |
| | 305 | .alf_cc_cr_filters_signalled_minus1 = alf->alf_cc_cr_filters_signalled_minus1, |
| | 306 | .alf_flags.bits = { |
| | 307 | .alf_luma_filter_signal_flag = alf->alf_luma_filter_signal_flag, |
| | 308 | .alf_chroma_filter_signal_flag = alf->alf_chroma_filter_signal_flag, |
| | 309 | .alf_cc_cb_filter_signal_flag = alf->alf_cc_cb_filter_signal_flag, |
| | 310 | .alf_cc_cr_filter_signal_flag = alf->alf_cc_cr_filter_signal_flag, |
| | 311 | .alf_luma_clip_flag = alf->alf_luma_clip_flag, |
| | 312 | .alf_chroma_clip_flag = alf->alf_chroma_clip_flag, |
| | 313 | } |
| | 314 | }; |
| | 315 | |
| | 316 | for (j = 0; j < 25; j++) |
| | 317 | alf_param.alf_luma_coeff_delta_idx[j] = alf->alf_luma_coeff_delta_idx[j]; |
| | 318 | |
| | 319 | for (j = 0; j < 25; j++) { |
| | 320 | for (k = 0; k < 12; k++) { |
| | 321 | alf_param.filtCoeff[j][k] = alf->alf_luma_coeff_abs[j][k] * (1 - 2 * alf->alf_luma_coeff_sign[j][k]); |
| | 322 | alf_param.alf_luma_clip_idx[j][k] = alf->alf_luma_clip_idx[j][k]; |
| | 323 | } |
| | 324 | } |
| | 325 | |
| | 326 | for (j = 0; j < 8; j++) { |
| | 327 | for (k = 0; k < 6; k++) { |
| | 328 | alf_param.AlfCoeffC[j][k] = alf->alf_chroma_coeff_abs[j][k] * (1 - 2 * alf->alf_chroma_coeff_sign[j][k]); |
| | 329 | alf_param.alf_chroma_clip_idx[j][k] = alf->alf_chroma_clip_idx[j][k]; |
| | 330 | } |
| | 331 | } |
| | 332 | |
| | 333 | for (j = 0; j < 4; j++) { |
| | 334 | for (k = 0; k < 7; k++) { |
| | 335 | if (alf->alf_cc_cb_mapped_coeff_abs[j][k]) |
| | 336 | alf_param.CcAlfApsCoeffCb[j][k] = (1 - 2 * alf->alf_cc_cb_coeff_sign[j][k]) * (1 << (alf->alf_cc_cb_mapped_coeff_abs[j][k] - 1)); |
| | 337 | if (alf->alf_cc_cr_mapped_coeff_abs[j][k]) |
| | 338 | alf_param.CcAlfApsCoeffCr[j][k] = (1 - 2 * alf->alf_cc_cr_coeff_sign[j][k]) * (1 << (alf->alf_cc_cr_mapped_coeff_abs[j][k] - 1)); |
| | 339 | } |
| | 340 | } |
| | 341 | |
| | 342 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 343 | VAAlfBufferType, |
| | 344 | &alf_param, sizeof(VAAlfDataVVC)); |
| | 345 | if (err < 0) |
| | 346 | goto fail; |
| | 347 | } |
| | 348 | } |
| | 349 | |
| | 350 | for (i = 0; i < VVC_MAX_LMCS_COUNT; i++) { |
| | 351 | const H266RawAPS *lmcs = h->ps.lmcs_list[i]; |
| | 352 | if (lmcs) { |
| | 353 | VALmcsDataVVC lmcs_param = { |
| | 354 | .aps_adaptation_parameter_set_id = i, |
| | 355 | .lmcs_min_bin_idx = lmcs->lmcs_min_bin_idx, |
| | 356 | .lmcs_delta_max_bin_idx = lmcs->lmcs_delta_max_bin_idx, |
| | 357 | .lmcsDeltaCrs = (1 - 2 * lmcs->lmcs_delta_sign_crs_flag) * lmcs->lmcs_delta_abs_crs, |
| | 358 | }; |
| | 359 | |
| | 360 | for (j = lmcs->lmcs_min_bin_idx; j <= 15 - lmcs->lmcs_delta_max_bin_idx; j++) |
| | 361 | lmcs_param.lmcsDeltaCW[j] = (1 - 2 * lmcs->lmcs_delta_sign_cw_flag[j]) * lmcs->lmcs_delta_abs_cw[j]; |
| | 362 | |
| | 363 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 364 | VALmcsBufferType, |
| | 365 | &lmcs_param, sizeof(VALmcsDataVVC)); |
| | 366 | if (err < 0) |
| | 367 | goto fail; |
| | 368 | } |
| | 369 | } |
| | 370 | |
| | 371 | for (i = 0; i < VVC_MAX_SL_COUNT; i++) { |
| | 372 | const VVCScalingList *sl = h->ps.scaling_list[i]; |
| | 373 | if (sl) { |
| | 374 | int l; |
| | 375 | |
| | 376 | VAScalingListVVC sl_param = { |
| | 377 | .aps_adaptation_parameter_set_id = i, |
| | 378 | }; |
| | 379 | |
| | 380 | for (j = 0; j < 14; j++) |
| | 381 | sl_param.ScalingMatrixDCRec[j] = sl->scaling_matrix_dc_rec[j]; |
| | 382 | |
| | 383 | for (j = 0; j < 2; j++) |
| | 384 | for (k = 0; k < 2; k++) |
| | 385 | for (l = 0; l < 2; l++) |
| | 386 | sl_param.ScalingMatrixRec2x2[j][k][l] = sl->scaling_matrix_rec[j][l * 2 + k]; |
| | 387 | |
| | 388 | for (j = 2; j < 8; j++) |
| | 389 | for (k = 0; k < 4; k++) |
| | 390 | for (l = 0; l < 4; l++) |
| | 391 | sl_param.ScalingMatrixRec4x4[j - 2][k][l] = sl->scaling_matrix_rec[j][l * 4 + k]; |
| | 392 | |
| | 393 | for (j = 8; j < 28; j++) |
| | 394 | for (k = 0; k < 8; k++) |
| | 395 | for (l = 0; l < 8; l++) |
| | 396 | sl_param.ScalingMatrixRec8x8[j - 8][k][l] = sl->scaling_matrix_rec[j][l * 8 + k]; |
| | 397 | |
| | 398 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 399 | VAIQMatrixBufferType, |
| | 400 | &sl_param, sizeof(VAScalingListVVC)); |
| | 401 | if (err < 0) |
| | 402 | goto fail; |
| | 403 | } |
| | 404 | } |
| | 405 | |
| | 406 | for (i = 0; i <= pps->pps_num_exp_tile_columns_minus1; i++) { |
| | 407 | tile_dim = pps->pps_tile_column_width_minus1[i]; |
| | 408 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 409 | VATileBufferType, |
| | 410 | &tile_dim, sizeof(tile_dim)); |
| | 411 | if (err < 0) |
| | 412 | goto fail; |
| | 413 | } |
| | 414 | |
| | 415 | for (i = 0; i <= pps->pps_num_exp_tile_rows_minus1; i++) { |
| | 416 | tile_dim = pps->pps_tile_row_height_minus1[i]; |
| | 417 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 418 | VATileBufferType, |
| | 419 | &tile_dim, sizeof(tile_dim)); |
| | 420 | if (err < 0) |
| | 421 | goto fail; |
| | 422 | } |
| | 423 | |
| | 424 | if (!pps->pps_no_pic_partition_flag && pps->pps_rect_slice_flag && !pps->pps_single_slice_per_subpic_flag) { |
| | 425 | for (i = 0; i <= pps->pps_num_slices_in_pic_minus1; i++) { |
| | 426 | for (j = 0; j < pps->pps_num_exp_slices_in_tile[i]; j++) { |
| | 427 | exp_slice_height_in_ctus[i + j] = pps->pps_exp_slice_height_in_ctus_minus1[i][j] + 1; |
| | 428 | } |
| | 429 | } |
| | 430 | for (i = 0; i <= pps->pps_num_slices_in_pic_minus1; i++) { |
| | 431 | VASliceStructVVC ss_param = { |
| | 432 | .SliceTopLeftTileIdx = pps->slice_top_left_tile_idx[i], |
| | 433 | .pps_slice_width_in_tiles_minus1 = pps->pps_slice_width_in_tiles_minus1[i], |
| | 434 | .pps_slice_height_in_tiles_minus1 = pps->pps_slice_height_in_tiles_minus1[i], |
| | 435 | }; |
| | 436 | |
| | 437 | if (pps->pps_slice_width_in_tiles_minus1[i] > 0 || pps->pps_slice_height_in_tiles_minus1[i] > 0) |
| | 438 | ss_param.pps_exp_slice_height_in_ctus_minus1 = 0; |
| | 439 | else { |
| | 440 | if (pps->num_slices_in_tile[i] == 1) |
| | 441 | ss_param.pps_exp_slice_height_in_ctus_minus1 = pps->row_height_val[pps->slice_top_left_tile_idx[i] / pps->num_tile_columns] - 1; |
| | 442 | else if (exp_slice_height_in_ctus[i]) |
| | 443 | ss_param.pps_exp_slice_height_in_ctus_minus1 = exp_slice_height_in_ctus[i] - 1; |
| | 444 | else |
| | 445 | continue; |
| | 446 | } |
| | 447 | |
| | 448 | err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic, |
| | 449 | VASliceStructBufferType, |
| | 450 | &ss_param, sizeof(VASliceStructVVC)); |
| | 451 | if (err < 0) |
| | 452 | goto fail; |
| | 453 | } |
| | 454 | } |
| | 455 | |
| | 456 | return 0; |
| | 457 | |
| | 458 | fail: |
| | 459 | ff_vaapi_decode_cancel(avctx, &pic->pic); |
| | 460 | return err; |
| | 461 | } |
| | 462 | |
| | 463 | static uint8_t get_ref_pic_index(const VVCContext *h, const VVCFrame *frame) |
| | 464 | { |
| | 465 | VVCFrameContext *fc = &h->fcs[(h->nb_frames + h->nb_fcs) % h->nb_fcs]; |
| | 466 | VAAPIDecodePictureVVC *pic = fc->ref->hwaccel_picture_private; |
| | 467 | VAPictureParameterBufferVVC *pp = (VAPictureParameterBufferVVC *)&pic->pic_param; |
| | 468 | uint8_t i; |
| | 469 | |
| | 470 | if (!frame) |
| | 471 | return 0xFF; |
| | 472 | |
| | 473 | for (i = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) { |
| | 474 | VASurfaceID pid = pp->ReferenceFrames[i].picture_id; |
| | 475 | int poc = pp->ReferenceFrames[i].pic_order_cnt; |
| | 476 | if (pid != VA_INVALID_ID && pid == ff_vaapi_get_surface_id(frame->frame) && poc == frame->poc) |
| | 477 | return i; |
| | 478 | } |
| | 479 | |
| | 480 | return 0xFF; |
| | 481 | } |
| | 482 | |
| | 483 | static int get_slice_data_byte_offset(const uint8_t *buffer, uint32_t size, const SliceContext* sc) |
| | 484 | { |
| | 485 | const H266RawSlice *slice = sc->ref; |
| | 486 | int num_identical_bytes = slice->data_size < 32 ? slice->data_size : 32; |
| | 487 | |
| | 488 | for (int i = 0; i < size; i++) { |
| | 489 | int skip_bytes = 0; |
| | 490 | if (i >=2 && buffer[i] == 0x03 && !buffer[i - 1] && !buffer[i - 2]) |
| | 491 | continue; |
| | 492 | |
| | 493 | for (int j = 0; j < num_identical_bytes; j++) { |
| | 494 | if (i >= 2 && buffer[i + j + skip_bytes] == 0x03 && !buffer[i + j + skip_bytes - 1] && !buffer[i + j + skip_bytes - 2]) |
| | 495 | skip_bytes++; |
| | 496 | |
| | 497 | if (buffer[i + j + skip_bytes] != slice->data[j]) |
| | 498 | break; |
| | 499 | |
| | 500 | if (j + 1 == num_identical_bytes) |
| | 501 | return i; |
| | 502 | } |
| | 503 | } |
| | 504 | |
| | 505 | return 0; |
| | 506 | } |
| | 507 | |
| | 508 | static int vaapi_vvc_decode_slice(AVCodecContext *avctx, |
| | 509 | const uint8_t *buffer, |
| | 510 | uint32_t size) |
| | 511 | { |
| | 512 | const VVCContext *h = avctx->priv_data; |
| | 513 | VVCFrameContext *fc = &h->fcs[(h->nb_frames + h->nb_fcs) % h->nb_fcs]; |
| | 514 | const SliceContext *sc = fc->slices[fc->nb_slices]; |
| | 515 | const H266RawPPS *pps = fc->ps.pps->r; |
| | 516 | const H266RawPictureHeader *ph = fc->ps.ph.r; |
| | 517 | const H266RawSliceHeader *sh = sc->sh.r; |
| | 518 | VAAPIDecodePictureVVC *pic = fc->ref->hwaccel_picture_private; |
| | 519 | VASliceParameterBufferVVC *slice_param = &pic->slice_param; |
| | 520 | int nb_list, i, err; |
| | 521 | |
| | 522 | *slice_param = (VASliceParameterBufferVVC) { |
| | 523 | .slice_data_size = size, |
| | 524 | .slice_data_offset = 0, |
| | 525 | .slice_data_flag = VA_SLICE_DATA_FLAG_ALL, |
| | 526 | .slice_data_byte_offset = get_slice_data_byte_offset(buffer, size, sc), |
| | 527 | .sh_subpic_id = sh->sh_subpic_id, |
| | 528 | .sh_slice_address = sh->sh_slice_address, |
| | 529 | .sh_num_tiles_in_slice_minus1 = sh->sh_num_tiles_in_slice_minus1, |
| | 530 | .sh_slice_type = sh->sh_slice_type, |
| | 531 | .sh_num_alf_aps_ids_luma = sh->sh_num_alf_aps_ids_luma, |
| | 532 | .sh_alf_aps_id_chroma = sh->sh_alf_aps_id_chroma, |
| | 533 | .sh_alf_cc_cb_aps_id = sh->sh_alf_cc_cb_aps_id, |
| | 534 | .sh_alf_cc_cr_aps_id = sh->sh_alf_cc_cr_aps_id, |
| | 535 | .NumRefIdxActive[0] = sh->num_ref_idx_active[0], |
| | 536 | .NumRefIdxActive[1] = sh->num_ref_idx_active[1], |
| | 537 | .sh_collocated_ref_idx = sh->sh_collocated_ref_idx, |
| | 538 | .SliceQpY = pps->pps_qp_delta_info_in_ph_flag ? |
| | 539 | 26 + pps->pps_init_qp_minus26 + ph->ph_qp_delta : |
| | 540 | 26 + pps->pps_init_qp_minus26 + sh->sh_qp_delta, |
| | 541 | .sh_cb_qp_offset = sh->sh_cb_qp_offset, |
| | 542 | .sh_cr_qp_offset = sh->sh_cr_qp_offset, |
| | 543 | .sh_joint_cbcr_qp_offset = sh->sh_joint_cbcr_qp_offset, |
| | 544 | .sh_luma_beta_offset_div2 = sh->sh_luma_beta_offset_div2, |
| | 545 | .sh_luma_tc_offset_div2 = sh->sh_luma_tc_offset_div2, |
| | 546 | .sh_cb_beta_offset_div2 = sh->sh_cb_beta_offset_div2, |
| | 547 | .sh_cb_tc_offset_div2 = sh->sh_cb_tc_offset_div2, |
| | 548 | .sh_cr_beta_offset_div2 = sh->sh_cr_beta_offset_div2, |
| | 549 | .sh_cr_tc_offset_div2 = sh->sh_cr_tc_offset_div2, |
| | 550 | .WPInfo = { |
| | 551 | .luma_log2_weight_denom = sh->sh_pred_weight_table.luma_log2_weight_denom, |
| | 552 | .delta_chroma_log2_weight_denom = sh->sh_pred_weight_table.delta_chroma_log2_weight_denom, |
| | 553 | .num_l0_weights = sh->sh_pred_weight_table.num_l0_weights, |
| | 554 | .num_l1_weights = sh->sh_pred_weight_table.num_l1_weights, |
| | 555 | }, |
| | 556 | .sh_flags.bits = { |
| | 557 | .sh_alf_enabled_flag = sh->sh_alf_enabled_flag, |
| | 558 | .sh_alf_cb_enabled_flag = sh->sh_alf_cb_enabled_flag, |
| | 559 | .sh_alf_cr_enabled_flag = sh->sh_alf_cr_enabled_flag, |
| | 560 | .sh_alf_cc_cb_enabled_flag = sh->sh_alf_cc_cb_enabled_flag, |
| | 561 | .sh_alf_cc_cr_enabled_flag = sh->sh_alf_cc_cr_enabled_flag, |
| | 562 | .sh_lmcs_used_flag = sh->sh_lmcs_used_flag, |
| | 563 | .sh_explicit_scaling_list_used_flag = sh->sh_explicit_scaling_list_used_flag, |
| | 564 | .sh_cabac_init_flag = sh->sh_cabac_init_flag, |
| | 565 | .sh_collocated_from_l0_flag = sh->sh_collocated_from_l0_flag, |
| | 566 | .sh_cu_chroma_qp_offset_enabled_flag = sh->sh_cu_chroma_qp_offset_enabled_flag, |
| | 567 | .sh_sao_luma_used_flag = sh->sh_sao_luma_used_flag, |
| | 568 | .sh_sao_chroma_used_flag = sh->sh_sao_chroma_used_flag, |
| | 569 | .sh_deblocking_filter_disabled_flag = sh->sh_deblocking_filter_disabled_flag, |
| | 570 | .sh_dep_quant_used_flag = sh->sh_dep_quant_used_flag, |
| | 571 | .sh_sign_data_hiding_used_flag = sh->sh_sign_data_hiding_used_flag, |
| | 572 | .sh_ts_residual_coding_disabled_flag = sh->sh_ts_residual_coding_disabled_flag, |
| | 573 | }, |
| | 574 | }; |
| | 575 | |
| | 576 | memset(&slice_param->RefPicList, 0xFF, sizeof(slice_param->RefPicList)); |
| | 577 | |
| | 578 | nb_list = (sh->sh_slice_type == VVC_SLICE_TYPE_B) ? |
| | 579 | 2 : (sh->sh_slice_type == VVC_SLICE_TYPE_I ? 0 : 1); |
| | 580 | for (int list_idx = 0; list_idx < nb_list; list_idx++) { |
| | 581 | RefPicList *rpl = &sc->rpl[list_idx]; |
| | 582 | |
| | 583 | for (i = 0; i < rpl->nb_refs; i++) |
| | 584 | slice_param->RefPicList[list_idx][i] = get_ref_pic_index(h, rpl->refs[i].ref); |
| | 585 | } |
| | 586 | |
| | 587 | for (i = 0; i < 7; i++) |
| | 588 | slice_param->sh_alf_aps_id_luma[i] = sh->sh_alf_aps_id_luma[i]; |
| | 589 | |
| | 590 | for (i = 0; i < 15; i++) { |
| | 591 | slice_param->WPInfo.luma_weight_l0_flag[i] = sh->sh_pred_weight_table.luma_weight_l0_flag[i]; |
| | 592 | slice_param->WPInfo.chroma_weight_l0_flag[i] = sh->sh_pred_weight_table.chroma_weight_l0_flag[i]; |
| | 593 | slice_param->WPInfo.delta_luma_weight_l0[i] = sh->sh_pred_weight_table.delta_luma_weight_l0[i]; |
| | 594 | slice_param->WPInfo.luma_offset_l0[i] = sh->sh_pred_weight_table.luma_offset_l0[i]; |
| | 595 | slice_param->WPInfo.luma_weight_l1_flag[i] = sh->sh_pred_weight_table.luma_weight_l1_flag[i]; |
| | 596 | slice_param->WPInfo.chroma_weight_l1_flag[i] = sh->sh_pred_weight_table.chroma_weight_l1_flag[i]; |
| | 597 | slice_param->WPInfo.delta_luma_weight_l1[i] = sh->sh_pred_weight_table.delta_luma_weight_l1[i]; |
| | 598 | slice_param->WPInfo.luma_offset_l1[i] = sh->sh_pred_weight_table.luma_offset_l1[i]; |
| | 599 | } |
| | 600 | |
| | 601 | for (i = 0; i < 15; i++) { |
| | 602 | for (int j = 0; j < 2; j++) { |
| | 603 | slice_param->WPInfo.delta_chroma_weight_l0[i][j] = sh->sh_pred_weight_table.delta_chroma_weight_l0[i][j]; |
| | 604 | slice_param->WPInfo.delta_chroma_offset_l0[i][j] = sh->sh_pred_weight_table.delta_chroma_offset_l0[i][j]; |
| | 605 | slice_param->WPInfo.delta_chroma_weight_l1[i][j] = sh->sh_pred_weight_table.delta_chroma_weight_l1[i][j]; |
| | 606 | slice_param->WPInfo.delta_chroma_offset_l1[i][j] = sh->sh_pred_weight_table.delta_chroma_offset_l1[i][j]; |
| | 607 | } |
| | 608 | } |
| | 609 | |
| | 610 | err = ff_vaapi_decode_make_slice_buffer(avctx, &pic->pic, |
| | 611 | &pic->slice_param, 1, |
| | 612 | sizeof(VASliceParameterBufferVVC), |
| | 613 | buffer, size); |
| | 614 | if (err) { |
| | 615 | ff_vaapi_decode_cancel(avctx, &pic->pic); |
| | 616 | return err; |
| | 617 | } |
| | 618 | |
| | 619 | return 0; |
| | 620 | } |
| | 621 | |
| | 622 | static int vaapi_vvc_end_frame(AVCodecContext *avctx) |
| | 623 | { |
| | 624 | |
| | 625 | const VVCContext *h = avctx->priv_data; |
| | 626 | VVCFrameContext *fc = &h->fcs[(h->nb_frames + h->nb_fcs) % h->nb_fcs]; |
| | 627 | VAAPIDecodePictureVVC *pic = fc->ref->hwaccel_picture_private; |
| | 628 | int ret; |
| | 629 | |
| | 630 | ret = ff_vaapi_decode_issue(avctx, &pic->pic); |
| | 631 | if (ret < 0) |
| | 632 | goto fail; |
| | 633 | |
| | 634 | pic->decode_issued = 1; |
| | 635 | |
| | 636 | return 0; |
| | 637 | |
| | 638 | fail: |
| | 639 | ff_vaapi_decode_cancel(avctx, &pic->pic); |
| | 640 | return ret; |
| | 641 | } |
| | 642 | |
| | 643 | const FFHWAccel ff_vvc_vaapi_hwaccel = { |
| | 644 | .p.name = "vvc_vaapi", |
| | 645 | .p.type = AVMEDIA_TYPE_VIDEO, |
| | 646 | .p.id = AV_CODEC_ID_VVC, |
| | 647 | .p.pix_fmt = AV_PIX_FMT_VAAPI, |
| | 648 | .start_frame = &vaapi_vvc_start_frame, |
| | 649 | .end_frame = &vaapi_vvc_end_frame, |
| | 650 | .decode_slice = &vaapi_vvc_decode_slice, |
| | 651 | .frame_priv_data_size = sizeof(VAAPIDecodePictureVVC), |
| | 652 | .init = &ff_vaapi_decode_init, |
| | 653 | .uninit = &ff_vaapi_decode_uninit, |
| | 654 | .frame_params = &ff_vaapi_common_frame_params, |
| | 655 | .priv_data_size = sizeof(VAAPIDecodeContext), |
| | 656 | .caps_internal = HWACCEL_CAP_ASYNC_SAFE, |
| | 657 | }; |