1 /*
2 * Copyright (c) 2015-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file media_ddi_decode_hevc_g12.cpp
24 //! \brief The class implementation of DdiDecodeHEVCG12 for HEVC decode
25 //!
26
27 #include "media_libva_decoder.h"
28 #include "media_libva_util.h"
29
30 #include "media_ddi_decode_hevc_g12.h"
31 #include "mos_solo_generic.h"
32 #include "codechal_memdecomp.h"
33 #include "media_ddi_decode_const.h"
34 #include "media_ddi_decode_const_g12.h"
35 #include "media_ddi_factory.h"
36 #include "media_libva_common.h"
37 #include "codec_def_decode_hevc.h"
38
ParseSliceParams(DDI_MEDIA_CONTEXT * mediaCtx,VASliceParameterBufferHEVC * slcParam,uint32_t numSlices)39 VAStatus DdiDecodeHEVCG12::ParseSliceParams(
40 DDI_MEDIA_CONTEXT *mediaCtx,
41 VASliceParameterBufferHEVC *slcParam,
42 uint32_t numSlices)
43 {
44 VASliceParameterBufferHEVC *slc = slcParam;
45 VASliceParameterBufferBase *slcBase = (VASliceParameterBufferBase *)slcParam;
46 bool isHevcRext = IsRextProfile();
47 bool isHevcScc = IsSccProfile();
48
49 PCODEC_HEVC_SLICE_PARAMS codecSlcParams = (PCODEC_HEVC_SLICE_PARAMS)(m_ddiDecodeCtx->DecodeParams.m_sliceParams);
50 codecSlcParams += m_ddiDecodeCtx->DecodeParams.m_numSlices;
51 PCODEC_HEVC_EXT_SLICE_PARAMS codecSclParamsRext = nullptr;
52 VASliceParameterBufferHEVCExtension *slcExtension = nullptr;
53 VASliceParameterBufferHEVCRext *slcRext = nullptr;
54
55 if(isHevcRext)
56 {
57 codecSclParamsRext = (PCODEC_HEVC_EXT_SLICE_PARAMS)(m_ddiDecodeCtx->DecodeParams.m_extSliceParams);
58 codecSclParamsRext += m_ddiDecodeCtx->DecodeParams.m_numSlices;
59 slcExtension = (VASliceParameterBufferHEVCExtension *)slcParam;
60 slc = &slcExtension->base;
61 slcRext = &slcExtension->rext;
62 }
63
64 if ((slcParam == nullptr) || (codecSlcParams == nullptr) || (isHevcRext && (codecSclParamsRext == nullptr || slcRext == nullptr)))
65 {
66 DDI_ASSERTMESSAGE("Invalid Parameter for Parsing HEVC Slice parameter\n");
67 return VA_STATUS_ERROR_INVALID_PARAMETER;
68 }
69
70 memset(codecSlcParams, 0, numSlices * sizeof(CODEC_HEVC_SLICE_PARAMS));
71 if(isHevcRext)
72 {
73 memset(codecSclParamsRext, 0, numSlices * sizeof(CODEC_HEVC_EXT_SLICE_PARAMS));
74 }
75
76 uint32_t sliceBaseOffset = GetBsBufOffset(m_groupIndex);
77 uint32_t i, j, slcCount;
78 for (slcCount = 0; slcCount < numSlices; slcCount++)
79 {
80 if (m_ddiDecodeCtx->bShortFormatInUse)
81 {
82 codecSlcParams->slice_data_size = slcBase->slice_data_size;
83 codecSlcParams->slice_data_offset = sliceBaseOffset + slcBase->slice_data_offset;
84 if (slcBase->slice_data_flag)
85 {
86 DDI_NORMALMESSAGE("The whole slice is not in the bitstream buffer for this Execute call");
87 }
88 slcBase++;
89 }
90 else
91 {
92 codecSlcParams->slice_data_size = slc->slice_data_size;
93 codecSlcParams->slice_data_offset = sliceBaseOffset + slc->slice_data_offset;
94 if (slcBase->slice_data_flag)
95 {
96 DDI_NORMALMESSAGE("The whole slice is not in the bitstream buffer for this Execute call");
97 }
98
99 codecSlcParams->ByteOffsetToSliceData = slc->slice_data_byte_offset;
100 codecSlcParams->NumEmuPrevnBytesInSliceHdr = slc->slice_data_num_emu_prevn_bytes;
101 codecSlcParams->slice_segment_address = slc->slice_segment_address;
102
103 for (i = 0; i < 2; i++)
104 {
105 for (j = 0; j < CODEC_MAX_NUM_REF_FRAME_HEVC; j++)
106 {
107 codecSlcParams->RefPicList[i][j].FrameIdx = (slc->RefPicList[i][j] == 0xff) ? 0x7f : slc->RefPicList[i][j];
108 }
109 }
110
111 codecSlcParams->LongSliceFlags.value = slc->LongSliceFlags.value;
112 codecSlcParams->collocated_ref_idx = slc->collocated_ref_idx;
113 codecSlcParams->num_ref_idx_l0_active_minus1 = slc->num_ref_idx_l0_active_minus1;
114 codecSlcParams->num_ref_idx_l1_active_minus1 = slc->num_ref_idx_l1_active_minus1;
115 codecSlcParams->slice_qp_delta = slc->slice_qp_delta;
116 codecSlcParams->slice_cb_qp_offset = slc->slice_cb_qp_offset;
117 codecSlcParams->slice_cr_qp_offset = slc->slice_cr_qp_offset;
118 codecSlcParams->slice_beta_offset_div2 = slc->slice_beta_offset_div2;
119 codecSlcParams->slice_tc_offset_div2 = slc->slice_tc_offset_div2;
120 codecSlcParams->luma_log2_weight_denom = slc->luma_log2_weight_denom;
121 codecSlcParams->delta_chroma_log2_weight_denom = slc->delta_chroma_log2_weight_denom;
122
123 MOS_SecureMemcpy(codecSlcParams->delta_luma_weight_l0,
124 15,
125 slc->delta_luma_weight_l0,
126 15);
127 MOS_SecureMemcpy(codecSlcParams->delta_luma_weight_l1,
128 15,
129 slc->delta_luma_weight_l1,
130 15);
131
132 MOS_SecureMemcpy(codecSlcParams->delta_chroma_weight_l0,
133 15 * 2,
134 slc->delta_chroma_weight_l0,
135 15 * 2);
136 MOS_SecureMemcpy(codecSlcParams->delta_chroma_weight_l1,
137 15 * 2,
138 slc->delta_chroma_weight_l1,
139 15 * 2);
140 codecSlcParams->five_minus_max_num_merge_cand = slc->five_minus_max_num_merge_cand;
141 codecSlcParams->num_entry_point_offsets = slc->num_entry_point_offsets;
142 codecSlcParams->EntryOffsetToSubsetArray = slc->entry_offset_to_subset_array;
143
144 if(!isHevcRext)
145 {
146 MOS_SecureMemcpy(codecSlcParams->luma_offset_l0,
147 15,
148 slc->luma_offset_l0,
149 15);
150 MOS_SecureMemcpy(codecSlcParams->luma_offset_l1,
151 15,
152 slc->luma_offset_l1,
153 15);
154 MOS_SecureMemcpy(codecSlcParams->ChromaOffsetL0,
155 15 * 2,
156 slc->ChromaOffsetL0,
157 15 * 2);
158 MOS_SecureMemcpy(codecSlcParams->ChromaOffsetL1,
159 15 * 2,
160 slc->ChromaOffsetL1,
161 15 * 2);
162
163 slc++;
164 }
165 else
166 {
167 MOS_SecureMemcpy(codecSclParamsRext->luma_offset_l0,
168 15 * sizeof(int16_t),
169 slcRext->luma_offset_l0,
170 15 * sizeof(int16_t));
171 MOS_SecureMemcpy(codecSclParamsRext->luma_offset_l1,
172 15 * sizeof(int16_t),
173 slcRext->luma_offset_l1,
174 15 * sizeof(int16_t));
175 MOS_SecureMemcpy(codecSclParamsRext->ChromaOffsetL0,
176 15 * 2 * sizeof(int16_t),
177 slcRext->ChromaOffsetL0,
178 15 * 2 * sizeof(int16_t));
179 MOS_SecureMemcpy(codecSclParamsRext->ChromaOffsetL1,
180 15 * 2 * sizeof(int16_t),
181 slcRext->ChromaOffsetL1,
182 15 * 2 * sizeof(int16_t));
183
184 codecSclParamsRext->cu_chroma_qp_offset_enabled_flag = slcRext->slice_ext_flags.bits.cu_chroma_qp_offset_enabled_flag;
185
186 if(isHevcScc)
187 {
188 codecSclParamsRext->use_integer_mv_flag = slcRext->slice_ext_flags.bits.use_integer_mv_flag;
189 codecSclParamsRext->slice_act_y_qp_offset = slcRext->slice_act_y_qp_offset;
190 codecSclParamsRext->slice_act_cb_qp_offset = slcRext->slice_act_cb_qp_offset;
191 codecSclParamsRext->slice_act_cr_qp_offset = slcRext->slice_act_cr_qp_offset;
192 }
193
194 codecSclParamsRext++;
195 slcExtension++;
196 slc = &slcExtension->base;
197 slcRext = &slcExtension->rext;
198 }
199 }
200 codecSlcParams++;
201 }
202 return VA_STATUS_SUCCESS;
203 }
204
ParsePicParams(DDI_MEDIA_CONTEXT * mediaCtx,VAPictureParameterBufferHEVC * picParam)205 VAStatus DdiDecodeHEVCG12::ParsePicParams(
206 DDI_MEDIA_CONTEXT *mediaCtx,
207 VAPictureParameterBufferHEVC *picParam)
208 {
209 PCODEC_HEVC_PIC_PARAMS codecPicParams = (PCODEC_HEVC_PIC_PARAMS)(m_ddiDecodeCtx->DecodeParams.m_picParams);
210 PCODEC_HEVC_EXT_PIC_PARAMS codecPicParamsExt = nullptr;
211 PCODEC_HEVC_SCC_PIC_PARAMS codecPicParamsScc = nullptr;
212
213 VAPictureParameterBufferHEVC *picParamBase = nullptr;
214 VAPictureParameterBufferHEVCRext *picParamRext = nullptr;
215 VAPictureParameterBufferHEVCScc *picParamScc = nullptr;
216 bool bIsHevcRext = IsRextProfile();
217 bool bIsHevcScc = IsSccProfile();
218
219 if(!bIsHevcRext)
220 {
221 picParamBase = picParam;
222 }
223 else
224 {
225 codecPicParamsExt = (PCODEC_HEVC_EXT_PIC_PARAMS)(m_ddiDecodeCtx->DecodeParams.m_extPicParams);
226 picParamBase = &((VAPictureParameterBufferHEVCExtension *)picParam)->base;
227 picParamRext = &((VAPictureParameterBufferHEVCExtension *)picParam)->rext;
228
229 if(bIsHevcScc)
230 {
231 codecPicParamsScc = (PCODEC_HEVC_SCC_PIC_PARAMS)(m_ddiDecodeCtx->DecodeParams.m_advPicParams);;
232 picParamScc = &((VAPictureParameterBufferHEVCExtension *)picParam)->scc;
233 }
234 }
235
236 if ((picParamBase == nullptr) || (codecPicParams == nullptr) ||
237 (bIsHevcRext && (picParamRext == nullptr || codecPicParamsExt == nullptr)) ||
238 (bIsHevcScc && (picParamScc == nullptr || codecPicParamsScc == nullptr)))
239 {
240 DDI_ASSERTMESSAGE("Invalid Parameter for Parsing HEVC Picture parameter\n");
241 return VA_STATUS_ERROR_INVALID_PARAMETER;
242 }
243
244 SetupCodecPicture(
245 mediaCtx,
246 &m_ddiDecodeCtx->RTtbl,
247 &codecPicParams->CurrPic,
248 picParamBase->CurrPic,
249 0, //picParam->pic_fields.bits.FieldPicFlag,
250 0, //picParam->pic_fields.bits.FieldPicFlag,
251 false);
252 if (codecPicParams->CurrPic.FrameIdx == (uint8_t)DDI_CODEC_INVALID_FRAME_INDEX)
253 {
254 return VA_STATUS_ERROR_INVALID_PARAMETER;
255 }
256
257 uint32_t i, j, k, l;
258 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
259 {
260 if (picParamBase->ReferenceFrames[i].picture_id != VA_INVALID_SURFACE)
261 {
262 UpdateRegisteredRTSurfaceFlag(&(m_ddiDecodeCtx->RTtbl),
263 DdiMedia_GetSurfaceFromVASurfaceID(mediaCtx, picParamBase->ReferenceFrames[i].picture_id));
264 }
265 SetupCodecPicture(
266 mediaCtx,
267 &m_ddiDecodeCtx->RTtbl,
268 &(codecPicParams->RefFrameList[i]),
269 picParamBase->ReferenceFrames[i],
270 0, //picParam->pic_fields.bits.FieldPicFlag,
271 0, //picParam->pic_fields.bits.FieldPicFlag,
272 true);
273 if (codecPicParams->RefFrameList[i].FrameIdx == (uint8_t)DDI_CODEC_INVALID_FRAME_INDEX)
274 {
275 //in case the ref frame sent from App is wrong, set it to invalid ref frame index in codechal.
276 codecPicParams->RefFrameList[i].FrameIdx = CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC;
277 }
278 }
279
280 codecPicParams->PicWidthInMinCbsY = picParamBase->pic_width_in_luma_samples / (1 << (picParamBase->log2_min_luma_coding_block_size_minus3 + 3));
281 codecPicParams->PicHeightInMinCbsY = picParamBase->pic_height_in_luma_samples / (1 << (picParamBase->log2_min_luma_coding_block_size_minus3 + 3));
282
283 codecPicParams->chroma_format_idc = picParamBase->pic_fields.bits.chroma_format_idc;
284 codecPicParams->separate_colour_plane_flag = picParamBase->pic_fields.bits.separate_colour_plane_flag;
285 codecPicParams->bit_depth_luma_minus8 = picParamBase->bit_depth_luma_minus8;
286 codecPicParams->bit_depth_chroma_minus8 = picParamBase->bit_depth_chroma_minus8;
287 codecPicParams->log2_max_pic_order_cnt_lsb_minus4 = picParamBase->log2_max_pic_order_cnt_lsb_minus4;
288 codecPicParams->NoPicReorderingFlag = picParamBase->pic_fields.bits.NoPicReorderingFlag;
289 codecPicParams->NoBiPredFlag = picParamBase->pic_fields.bits.NoBiPredFlag;
290
291 codecPicParams->sps_max_dec_pic_buffering_minus1 = picParamBase->sps_max_dec_pic_buffering_minus1;
292 codecPicParams->log2_min_luma_coding_block_size_minus3 = picParamBase->log2_min_luma_coding_block_size_minus3;
293 codecPicParams->log2_diff_max_min_luma_coding_block_size = picParamBase->log2_diff_max_min_luma_coding_block_size;
294 codecPicParams->log2_min_transform_block_size_minus2 = picParamBase->log2_min_transform_block_size_minus2;
295 codecPicParams->log2_diff_max_min_transform_block_size = picParamBase->log2_diff_max_min_transform_block_size;
296 codecPicParams->max_transform_hierarchy_depth_inter = picParamBase->max_transform_hierarchy_depth_inter;
297 codecPicParams->max_transform_hierarchy_depth_intra = picParamBase->max_transform_hierarchy_depth_intra;
298 codecPicParams->num_short_term_ref_pic_sets = picParamBase->num_short_term_ref_pic_sets;
299 codecPicParams->num_long_term_ref_pic_sps = picParamBase->num_long_term_ref_pic_sps;
300 codecPicParams->num_ref_idx_l0_default_active_minus1 = picParamBase->num_ref_idx_l0_default_active_minus1;
301 codecPicParams->num_ref_idx_l1_default_active_minus1 = picParamBase->num_ref_idx_l1_default_active_minus1;
302 codecPicParams->init_qp_minus26 = picParamBase->init_qp_minus26;
303 codecPicParams->ucNumDeltaPocsOfRefRpsIdx = 0; //redundant parameter, decoder may ignore
304 codecPicParams->wNumBitsForShortTermRPSInSlice = picParamBase->st_rps_bits;
305
306 //dwCodingParamToolFlags
307 codecPicParams->scaling_list_enabled_flag = picParamBase->pic_fields.bits.scaling_list_enabled_flag;
308 codecPicParams->amp_enabled_flag = picParamBase->pic_fields.bits.amp_enabled_flag;
309 codecPicParams->sample_adaptive_offset_enabled_flag = picParamBase->slice_parsing_fields.bits.sample_adaptive_offset_enabled_flag;
310 codecPicParams->pcm_enabled_flag = picParamBase->pic_fields.bits.pcm_enabled_flag;
311 codecPicParams->pcm_sample_bit_depth_luma_minus1 = picParamBase->pcm_sample_bit_depth_luma_minus1;
312 codecPicParams->pcm_sample_bit_depth_chroma_minus1 = picParamBase->pcm_sample_bit_depth_chroma_minus1;
313 codecPicParams->log2_min_pcm_luma_coding_block_size_minus3 = picParamBase->log2_min_pcm_luma_coding_block_size_minus3;
314 codecPicParams->log2_diff_max_min_pcm_luma_coding_block_size = picParamBase->log2_diff_max_min_pcm_luma_coding_block_size;
315 codecPicParams->pcm_loop_filter_disabled_flag = picParamBase->pic_fields.bits.pcm_loop_filter_disabled_flag;
316 codecPicParams->long_term_ref_pics_present_flag = picParamBase->slice_parsing_fields.bits.long_term_ref_pics_present_flag;
317 codecPicParams->sps_temporal_mvp_enabled_flag = picParamBase->slice_parsing_fields.bits.sps_temporal_mvp_enabled_flag;
318 codecPicParams->strong_intra_smoothing_enabled_flag = picParamBase->pic_fields.bits.strong_intra_smoothing_enabled_flag;
319 codecPicParams->dependent_slice_segments_enabled_flag = picParamBase->slice_parsing_fields.bits.dependent_slice_segments_enabled_flag;
320 codecPicParams->output_flag_present_flag = picParamBase->slice_parsing_fields.bits.output_flag_present_flag;
321 codecPicParams->num_extra_slice_header_bits = picParamBase->num_extra_slice_header_bits;
322 codecPicParams->sign_data_hiding_enabled_flag = picParamBase->pic_fields.bits.sign_data_hiding_enabled_flag;
323 codecPicParams->cabac_init_present_flag = picParamBase->slice_parsing_fields.bits.cabac_init_present_flag;
324
325 codecPicParams->constrained_intra_pred_flag = picParamBase->pic_fields.bits.constrained_intra_pred_flag;
326 codecPicParams->transform_skip_enabled_flag = picParamBase->pic_fields.bits.transform_skip_enabled_flag;
327 codecPicParams->cu_qp_delta_enabled_flag = picParamBase->pic_fields.bits.cu_qp_delta_enabled_flag;
328 codecPicParams->pps_slice_chroma_qp_offsets_present_flag = picParamBase->slice_parsing_fields.bits.pps_slice_chroma_qp_offsets_present_flag;
329 codecPicParams->weighted_pred_flag = picParamBase->pic_fields.bits.weighted_pred_flag;
330 codecPicParams->weighted_bipred_flag = picParamBase->pic_fields.bits.weighted_bipred_flag;
331 codecPicParams->transquant_bypass_enabled_flag = picParamBase->pic_fields.bits.transquant_bypass_enabled_flag;
332 codecPicParams->tiles_enabled_flag = picParamBase->pic_fields.bits.tiles_enabled_flag;
333 codecPicParams->entropy_coding_sync_enabled_flag = picParamBase->pic_fields.bits.entropy_coding_sync_enabled_flag;
334 /*For va, uniform_spacing_flag==1, application should populate
335 column_width_minus[], and row_height_minus1[] with approperiate values. */
336 codecPicParams->uniform_spacing_flag = 0;
337 codecPicParams->loop_filter_across_tiles_enabled_flag = picParamBase->pic_fields.bits.loop_filter_across_tiles_enabled_flag;
338 codecPicParams->pps_loop_filter_across_slices_enabled_flag = picParamBase->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag;
339 codecPicParams->deblocking_filter_override_enabled_flag = picParamBase->slice_parsing_fields.bits.deblocking_filter_override_enabled_flag;
340 codecPicParams->pps_deblocking_filter_disabled_flag = picParamBase->slice_parsing_fields.bits.pps_disable_deblocking_filter_flag;
341 codecPicParams->lists_modification_present_flag = picParamBase->slice_parsing_fields.bits.lists_modification_present_flag;
342 codecPicParams->slice_segment_header_extension_present_flag = picParamBase->slice_parsing_fields.bits.slice_segment_header_extension_present_flag;
343 codecPicParams->IrapPicFlag = picParamBase->slice_parsing_fields.bits.RapPicFlag;
344 codecPicParams->IdrPicFlag = picParamBase->slice_parsing_fields.bits.IdrPicFlag;
345 codecPicParams->IntraPicFlag = picParamBase->slice_parsing_fields.bits.IntraPicFlag;
346
347 codecPicParams->pps_cb_qp_offset = picParamBase->pps_cb_qp_offset;
348 codecPicParams->pps_cr_qp_offset = picParamBase->pps_cr_qp_offset;
349 codecPicParams->num_tile_columns_minus1 = picParamBase->num_tile_columns_minus1;
350 codecPicParams->num_tile_rows_minus1 = picParamBase->num_tile_rows_minus1;
351
352 for (i = 0; i < HEVC_NUM_MAX_TILE_COLUMN - 1; i++)
353 {
354 codecPicParams->column_width_minus1[i] = picParamBase->column_width_minus1[i];
355 }
356 for (i = 0; i < HEVC_NUM_MAX_TILE_ROW - 1; i++)
357 {
358 codecPicParams->row_height_minus1[i] = picParamBase->row_height_minus1[i];
359 }
360
361 codecPicParams->diff_cu_qp_delta_depth = picParamBase->diff_cu_qp_delta_depth;
362 codecPicParams->pps_beta_offset_div2 = picParamBase->pps_beta_offset_div2;
363 codecPicParams->pps_tc_offset_div2 = picParamBase->pps_tc_offset_div2;
364 codecPicParams->log2_parallel_merge_level_minus2 = picParamBase->log2_parallel_merge_level_minus2;
365 codecPicParams->CurrPicOrderCntVal = picParamBase->CurrPic.pic_order_cnt;
366
367 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
368 {
369 codecPicParams->PicOrderCntValList[i] = picParamBase->ReferenceFrames[i].pic_order_cnt;
370 }
371
372 for (i = 0; i < 8; i++)
373 {
374 codecPicParams->RefPicSetStCurrBefore[i] = 0xff;
375 codecPicParams->RefPicSetStCurrAfter[i] = 0xff;
376 codecPicParams->RefPicSetLtCurr[i] = 0xff;
377 }
378
379 j = k = l = 0;
380
381 for (i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
382 {
383 if (picParamBase->ReferenceFrames[i].flags & VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE)
384 {
385 DDI_CHK_LESS(j, 8, "RefPicSetStCurrBefore[] index out of bounds.", VA_STATUS_ERROR_MAX_NUM_EXCEEDED);
386 codecPicParams->RefPicSetStCurrBefore[j++] = i;
387 }
388 else if (picParamBase->ReferenceFrames[i].flags & VA_PICTURE_HEVC_RPS_ST_CURR_AFTER)
389 {
390 DDI_CHK_LESS(k, 8, "RefPicSetStCurrAfter[] index out of bounds.", VA_STATUS_ERROR_MAX_NUM_EXCEEDED);
391 codecPicParams->RefPicSetStCurrAfter[k++] = i;
392 }
393 else if (picParamBase->ReferenceFrames[i].flags & VA_PICTURE_HEVC_RPS_LT_CURR)
394 {
395 DDI_CHK_LESS(l, 8, "RefPicSetLtCurr[] index out of bounds.", VA_STATUS_ERROR_MAX_NUM_EXCEEDED);
396 codecPicParams->RefPicSetLtCurr[l++] = i;
397 }
398 }
399
400 codecPicParams->RefFieldPicFlag = 0;
401 codecPicParams->RefBottomFieldFlag = 0;
402 codecPicParams->StatusReportFeedbackNumber = 0;
403
404 if (bIsHevcRext)
405 {
406 codecPicParamsExt->PicRangeExtensionFlags.dwRangeExtensionPropertyFlags = picParamRext->range_extension_pic_fields.value;
407 codecPicParamsExt->diff_cu_chroma_qp_offset_depth = picParamRext->diff_cu_chroma_qp_offset_depth;
408 codecPicParamsExt->chroma_qp_offset_list_len_minus1 = picParamRext->chroma_qp_offset_list_len_minus1;
409 codecPicParamsExt->log2_sao_offset_scale_luma = picParamRext->log2_sao_offset_scale_luma;
410 codecPicParamsExt->log2_sao_offset_scale_chroma = picParamRext->log2_sao_offset_scale_chroma;
411 codecPicParamsExt->log2_max_transform_skip_block_size_minus2 = picParamRext->log2_max_transform_skip_block_size_minus2;
412
413 for (i = 0; i < 6; i++)
414 {
415 codecPicParamsExt->cb_qp_offset_list[i] = picParamRext->cb_qp_offset_list[i];
416 codecPicParamsExt->cr_qp_offset_list[i] = picParamRext->cr_qp_offset_list[i];
417 }
418 }
419
420 if(bIsHevcScc)
421 {
422 codecPicParamsScc->PicSCCExtensionFlags.dwScreenContentCodingPropertyFlags = picParamScc->screen_content_pic_fields.value;
423 codecPicParamsScc->palette_max_size = picParamScc->palette_max_size;
424 codecPicParamsScc->delta_palette_max_predictor_size = picParamScc->delta_palette_max_predictor_size;
425 codecPicParamsScc->PredictorPaletteSize = picParamScc->predictor_palette_size;
426 codecPicParamsScc->pps_act_y_qp_offset_plus5 = picParamScc->pps_act_y_qp_offset_plus5;
427 codecPicParamsScc->pps_act_cb_qp_offset_plus5 = picParamScc->pps_act_cb_qp_offset_plus5;
428 codecPicParamsScc->pps_act_cr_qp_offset_plus3 = picParamScc->pps_act_cr_qp_offset_plus3;
429 uint32_t uiCopySize = sizeof(codecPicParamsScc->PredictorPaletteEntries);
430 MOS_SecureMemcpy(&codecPicParamsScc->PredictorPaletteEntries, uiCopySize, &picParamScc->predictor_palette_entries, uiCopySize);
431 }
432
433 return VA_STATUS_SUCCESS;
434 }
435
GetFormat()436 MOS_FORMAT DdiDecodeHEVCG12::GetFormat()
437 {
438 MOS_FORMAT Format = Format_NV12;
439 DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_ddiDecodeCtx->RTtbl);
440 CodechalDecodeParams *decodeParams = &m_ddiDecodeCtx->DecodeParams;
441 CODEC_HEVC_PIC_PARAMS *picParams = (CODEC_HEVC_PIC_PARAMS *)decodeParams->m_picParams;
442 if ((m_ddiDecodeAttr->profile == VAProfileHEVCMain10) &&
443 ((picParams->bit_depth_luma_minus8 ||
444 picParams->bit_depth_chroma_minus8)))
445 {
446 Format = Format_P010;
447 if (picParams->chroma_format_idc == 2)
448 {
449 Format = Format_Y210;
450 }
451 else if (picParams->chroma_format_idc == 3)
452 {
453 Format = Format_Y410;
454 }
455 }
456 else if(m_ddiDecodeAttr->profile == VAProfileHEVCMain10
457 && picParams->bit_depth_luma_minus8 == 0
458 && picParams->bit_depth_chroma_minus8 == 0
459 && rtTbl->pCurrentRT->format == Media_Format_P010)
460 {
461 // for hevc deocde 8bit in 10bit, the app will pass the render
462 // target surface with the P010.
463 Format = Format_P010;
464 }
465 else if(m_ddiDecodeAttr->profile == VAProfileHEVCMain12)
466 {
467 Format = Format_P016;
468 }
469 else if(m_ddiDecodeAttr->profile == VAProfileHEVCMain422_10
470 || m_ddiDecodeAttr->profile == VAProfileHEVCMain422_12
471 || m_ddiDecodeAttr->profile == VAProfileHEVCMain444
472 || m_ddiDecodeAttr->profile == VAProfileHEVCMain444_10
473 || m_ddiDecodeAttr->profile == VAProfileHEVCMain444_12)
474 {
475 Format = Format_NV12;
476 if(picParams->bit_depth_luma_minus8 == 0
477 && picParams->bit_depth_chroma_minus8 == 0) //8bit
478 {
479 if (picParams->chroma_format_idc == 1) //420
480 {
481 Format = Format_NV12;
482 if(rtTbl->pCurrentRT->format == Media_Format_P010)
483 {
484 Format = Format_P010;
485 }
486 else if(rtTbl->pCurrentRT->format == Media_Format_P016 || rtTbl->pCurrentRT->format == Media_Format_P012)
487 {
488 Format = Format_P016;
489 }
490 }
491 else if (picParams->chroma_format_idc == 2) //422
492 {
493 Format = Format_YUY2;
494 if(rtTbl->pCurrentRT->format == Media_Format_Y210)
495 {
496 Format = Format_Y210;
497 }
498 #if VA_CHECK_VERSION(1, 9, 0)
499 else if(rtTbl->pCurrentRT->format == Media_Format_Y216 || rtTbl->pCurrentRT->format == Media_Format_Y212)
500 #else
501 else if(rtTbl->pCurrentRT->format == Media_Format_Y216)
502 #endif
503 {
504 Format = Format_Y216;
505 }
506 }
507 else //444
508 {
509 Format = Format_AYUV;
510 if(rtTbl->pCurrentRT->format == Media_Format_Y410)
511 {
512 Format = Format_Y410;
513 }
514 #if VA_CHECK_VERSION(1, 9, 0)
515 else if(rtTbl->pCurrentRT->format == Media_Format_Y416 || rtTbl->pCurrentRT->format == Media_Format_Y412)
516 #else
517 else if(rtTbl->pCurrentRT->format == Media_Format_Y416)
518 #endif
519 {
520 Format = Format_Y416;
521 }
522 }
523 }
524 else if(picParams->bit_depth_luma_minus8 == 1
525 || picParams->bit_depth_chroma_minus8 == 1
526 || picParams->bit_depth_luma_minus8 == 2
527 || picParams->bit_depth_chroma_minus8 == 2) //10bit
528 {
529 if (picParams->chroma_format_idc == 1) //420
530 {
531 Format = Format_P010;
532 if(rtTbl->pCurrentRT->format == Media_Format_P016 || rtTbl->pCurrentRT->format == Media_Format_P012)
533 {
534 Format = Format_P016;
535 }
536 }
537 else if (picParams->chroma_format_idc == 2) //422
538 {
539 Format = Format_Y210;
540 #if VA_CHECK_VERSION(1, 9, 0)
541 if(rtTbl->pCurrentRT->format == Media_Format_Y216 || rtTbl->pCurrentRT->format == Media_Format_Y212)
542 #else
543 if(rtTbl->pCurrentRT->format == Media_Format_Y216)
544 #endif
545 {
546 Format = Format_Y216;
547 }
548 }
549 else //444
550 {
551 Format = Format_Y410;
552 #if VA_CHECK_VERSION(1, 9, 0)
553 if(rtTbl->pCurrentRT->format == Media_Format_Y416 || rtTbl->pCurrentRT->format == Media_Format_Y412)
554 #else
555 if(rtTbl->pCurrentRT->format == Media_Format_Y416)
556 #endif
557 {
558 Format = Format_Y416;
559 }
560 }
561 }
562 else if(picParams->bit_depth_luma_minus8 >= 3
563 || picParams->bit_depth_chroma_minus8 >= 3) //12bit
564 {
565 if (picParams->chroma_format_idc == 1) //420
566 {
567 Format = Format_P016;
568 }
569 else if (picParams->chroma_format_idc == 2) //422
570 {
571 Format = Format_Y216;
572 }
573 else //444
574 {
575 Format = Format_Y416;
576 }
577 }
578 }
579 else if(m_ddiDecodeAttr->profile == VAProfileHEVCSccMain10)
580 {
581 //420 10bit
582 Format = Format_P010;
583 }
584 else if (m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444 ||
585 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444_10)
586 {
587 //420/422/444 8bit
588 if((picParams->bit_depth_luma_minus8 == 0) &&
589 (picParams->bit_depth_chroma_minus8 == 0))
590 {
591 if (picParams->chroma_format_idc == 2)
592 {
593 Format = Format_YUY2;
594 }
595 else if (picParams->chroma_format_idc == 3)
596 {
597 Format = Format_AYUV;
598 }
599 else
600 {
601 Format = Format_NV12;
602 }
603 }
604 else
605 {
606 //10bit
607 if (picParams->chroma_format_idc == 2)
608 {
609 Format = Format_Y210;
610 }
611 else if (picParams->chroma_format_idc == 3)
612 {
613 Format = Format_Y410;
614 }
615 else
616 {
617 Format = Format_P010;
618 }
619 }
620 }
621
622 return Format;
623 }
624
AllocSliceParamContext(uint32_t numSlices)625 VAStatus DdiDecodeHEVCG12::AllocSliceParamContext(
626 uint32_t numSlices)
627 {
628 uint32_t baseSize = sizeof(CODEC_HEVC_SLICE_PARAMS);
629
630 if (m_sliceParamBufNum < (m_ddiDecodeCtx->DecodeParams.m_numSlices + numSlices))
631 {
632 // in order to avoid that the buffer is reallocated multi-times,
633 // extra 10 slices are added.
634 uint32_t extraSlices = numSlices + 10;
635
636 m_ddiDecodeCtx->DecodeParams.m_sliceParams = realloc(m_ddiDecodeCtx->DecodeParams.m_sliceParams,
637 baseSize * (m_sliceParamBufNum + extraSlices));
638
639 if (m_ddiDecodeCtx->DecodeParams.m_sliceParams == nullptr)
640 {
641 return VA_STATUS_ERROR_ALLOCATION_FAILED;
642 }
643
644 memset((void *)((uint8_t *)m_ddiDecodeCtx->DecodeParams.m_sliceParams + baseSize * m_sliceParamBufNum), 0, baseSize * extraSlices);
645
646 if(IsRextProfile())
647 {
648 uint32_t rextSize = sizeof(CODEC_HEVC_EXT_SLICE_PARAMS);
649 m_ddiDecodeCtx->DecodeParams.m_extSliceParams = realloc(m_ddiDecodeCtx->DecodeParams.m_extSliceParams,
650 rextSize * (m_sliceParamBufNum + extraSlices));
651
652 if (m_ddiDecodeCtx->DecodeParams.m_extSliceParams == nullptr)
653 {
654 return VA_STATUS_ERROR_ALLOCATION_FAILED;
655 }
656
657 memset((void *)((uint8_t *)m_ddiDecodeCtx->DecodeParams.m_extSliceParams + rextSize * m_sliceParamBufNum), 0, rextSize * extraSlices);
658 }
659
660 m_sliceParamBufNum += extraSlices;
661 }
662
663 return VA_STATUS_SUCCESS;
664 }
665
InitResourceBuffer()666 VAStatus DdiDecodeHEVCG12::InitResourceBuffer()
667 {
668 VAStatus vaStatus = VA_STATUS_SUCCESS;
669
670 DDI_CODEC_COM_BUFFER_MGR *bufMgr = &(m_ddiDecodeCtx->BufMgr);
671 bufMgr->pSliceData = nullptr;
672
673 bufMgr->ui64BitstreamOrder = 0;
674
675 if(m_width * m_height < CODEC_720P_MAX_PIC_WIDTH * CODEC_720P_MAX_PIC_HEIGHT)
676 {
677 bufMgr->dwMaxBsSize = m_width * m_height * 3 / 2;
678 }
679 else if(m_width * m_height < CODEC_4K_MAX_PIC_WIDTH * CODEC_4K_MAX_PIC_HEIGHT)
680 {
681 bufMgr->dwMaxBsSize = m_width * m_height * 3 / 8;
682 }
683 else
684 {
685 bufMgr->dwMaxBsSize = m_width * m_height * 3 / 16;
686 }
687
688 // minimal 10k bytes for some special case. Will refractor this later
689 if (bufMgr->dwMaxBsSize < DDI_CODEC_MIN_VALUE_OF_MAX_BS_SIZE)
690 {
691 bufMgr->dwMaxBsSize = DDI_CODEC_MIN_VALUE_OF_MAX_BS_SIZE;
692 }
693
694 int32_t i;
695 // init decode bitstream buffer object
696 for (i = 0; i < DDI_CODEC_MAX_BITSTREAM_BUFFER; i++)
697 {
698 bufMgr->pBitStreamBuffObject[i] = (DDI_MEDIA_BUFFER *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_BUFFER));
699 if (bufMgr->pBitStreamBuffObject[i] == nullptr)
700 {
701 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
702 goto finish;
703 }
704 bufMgr->pBitStreamBuffObject[i]->iSize = bufMgr->dwMaxBsSize;
705 bufMgr->pBitStreamBuffObject[i]->uiType = VASliceDataBufferType;
706 bufMgr->pBitStreamBuffObject[i]->format = Media_Format_Buffer;
707 bufMgr->pBitStreamBuffObject[i]->uiOffset = 0;
708 bufMgr->pBitStreamBuffObject[i]->bo = nullptr;
709 bufMgr->pBitStreamBase[i] = nullptr;
710 }
711
712 // The pSliceData can be allocated on demand. So the default size is wPicHeightInLCU.
713 // Currently the LCU32 is used.
714 bufMgr->m_maxNumSliceData = MOS_ALIGN_CEIL(m_height, 32) / 32;
715 bufMgr->pSliceData = (DDI_CODEC_BITSTREAM_BUFFER_INFO *)MOS_AllocAndZeroMemory(sizeof(bufMgr->pSliceData[0]) *
716 bufMgr->m_maxNumSliceData);
717
718 if (bufMgr->pSliceData == nullptr)
719 {
720 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
721 goto finish;
722 }
723
724 bufMgr->dwNumSliceData = 0;
725 bufMgr->dwNumSliceControl = 0;
726
727 /* as it can be increased on demand, the initial number will be based on LCU32 */
728 m_sliceCtrlBufNum = MOS_ALIGN_CEIL(m_height, 32) / 32;
729
730 if (m_ddiDecodeCtx->bShortFormatInUse)
731 {
732 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC = (VASliceParameterBufferBase *)
733 MOS_AllocAndZeroMemory(sizeof(VASliceParameterBufferBase) * m_sliceCtrlBufNum);
734 if (bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC == nullptr)
735 {
736 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
737 goto finish;
738 }
739 }
740 else if(!IsRextProfile())
741 {
742 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC = (VASliceParameterBufferHEVC *)
743 MOS_AllocAndZeroMemory(sizeof(VASliceParameterBufferHEVC) * m_sliceCtrlBufNum);
744 if (bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC == nullptr)
745 {
746 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
747 goto finish;
748 }
749 }
750 else
751 {
752 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext= (VASliceParameterBufferHEVCExtension*)
753 MOS_AllocAndZeroMemory(sizeof(VASliceParameterBufferHEVCExtension) * m_sliceCtrlBufNum);
754 if (bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext== nullptr)
755 {
756 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
757 goto finish;
758 }
759 }
760
761 return VA_STATUS_SUCCESS;
762
763 finish:
764 FreeResourceBuffer();
765 return vaStatus;
766 }
767
FreeResourceBuffer()768 void DdiDecodeHEVCG12::FreeResourceBuffer()
769 {
770 DDI_CODEC_COM_BUFFER_MGR *bufMgr = &(m_ddiDecodeCtx->BufMgr);
771
772 int32_t i;
773 for (i = 0; i < DDI_CODEC_MAX_BITSTREAM_BUFFER; i++)
774 {
775 if (bufMgr->pBitStreamBase[i])
776 {
777 DdiMediaUtil_UnlockBuffer(bufMgr->pBitStreamBuffObject[i]);
778 bufMgr->pBitStreamBase[i] = nullptr;
779 }
780 if (bufMgr->pBitStreamBuffObject[i])
781 {
782 DdiMediaUtil_FreeBuffer(bufMgr->pBitStreamBuffObject[i]);
783 MOS_FreeMemory(bufMgr->pBitStreamBuffObject[i]);
784 bufMgr->pBitStreamBuffObject[i] = nullptr;
785 }
786 }
787
788 if (bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC)
789 {
790 MOS_FreeMemory(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC);
791 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC = nullptr;
792 }
793 if (bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC)
794 {
795 MOS_FreeMemory(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC);
796 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC = nullptr;
797 }
798 if (bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext)
799 {
800 MOS_FreeMemory(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext);
801 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext = nullptr;
802 }
803
804 // free decode bitstream buffer object
805 MOS_FreeMemory(bufMgr->pSliceData);
806 bufMgr->pSliceData = nullptr;
807
808 return;
809 }
810
GetPicParamBuf(DDI_CODEC_COM_BUFFER_MGR * bufMgr)811 uint8_t* DdiDecodeHEVCG12::GetPicParamBuf(
812 DDI_CODEC_COM_BUFFER_MGR *bufMgr)
813 {
814 if(!IsRextProfile())
815 {
816 return (uint8_t*)(&(bufMgr->Codec_Param.Codec_Param_HEVC.PicParamHEVC));
817 }
818 else
819 {
820 return (uint8_t*)(&(bufMgr->Codec_Param.Codec_Param_HEVC.PicParamHEVCRext));
821 }
822 }
823
AllocSliceControlBuffer(DDI_MEDIA_BUFFER * buf)824 VAStatus DdiDecodeHEVCG12::AllocSliceControlBuffer(
825 DDI_MEDIA_BUFFER *buf)
826 {
827 DDI_CODEC_COM_BUFFER_MGR *bufMgr;
828 uint32_t availSize;
829 uint32_t newSize;
830
831 bufMgr = &(m_ddiDecodeCtx->BufMgr);
832 availSize = m_sliceCtrlBufNum - bufMgr->dwNumSliceControl;
833
834 if(buf->uiNumElements < 1 || buf->iSize < 1)
835 return VA_STATUS_ERROR_ALLOCATION_FAILED;
836
837 if(m_ddiDecodeCtx->bShortFormatInUse)
838 {
839 if(availSize < buf->uiNumElements)
840 {
841 if (buf->iSize / buf->uiNumElements != sizeof(VASliceParameterBufferBase))
842 return VA_STATUS_ERROR_ALLOCATION_FAILED;
843
844 newSize = sizeof(VASliceParameterBufferBase) * (m_sliceCtrlBufNum - availSize + buf->uiNumElements);
845 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC = (VASliceParameterBufferBase *)realloc(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC, newSize);
846 if(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC == nullptr)
847 {
848 return VA_STATUS_ERROR_ALLOCATION_FAILED;
849 }
850 MOS_ZeroMemory(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC + m_sliceCtrlBufNum, sizeof(VASliceParameterBufferBase) * (buf->uiNumElements - availSize));
851 m_sliceCtrlBufNum = m_sliceCtrlBufNum - availSize + buf->uiNumElements;
852 }
853 buf->pData = (uint8_t*)bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufBaseHEVC;
854 buf->uiOffset = bufMgr->dwNumSliceControl * sizeof(VASliceParameterBufferBase);
855 }
856 else
857 {
858 if(!IsRextProfile())
859 {
860 if(availSize < buf->uiNumElements)
861 {
862 if (buf->iSize / buf->uiNumElements != sizeof(VASliceParameterBufferHEVC))
863 return VA_STATUS_ERROR_ALLOCATION_FAILED;
864
865 newSize = sizeof(VASliceParameterBufferHEVC) * (m_sliceCtrlBufNum - availSize + buf->uiNumElements);
866 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC = (VASliceParameterBufferHEVC *)realloc(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC, newSize);
867 if(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC == nullptr)
868 {
869 return VA_STATUS_ERROR_ALLOCATION_FAILED;
870 }
871 MOS_ZeroMemory(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC + m_sliceCtrlBufNum, sizeof(VASliceParameterBufferHEVC) * (buf->uiNumElements - availSize));
872 m_sliceCtrlBufNum = m_sliceCtrlBufNum - availSize + buf->uiNumElements;
873 }
874 buf->pData = (uint8_t*)bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVC;
875 buf->uiOffset = bufMgr->dwNumSliceControl * sizeof(VASliceParameterBufferHEVC);
876 }
877 else
878 {
879 if(availSize < buf->uiNumElements)
880 {
881 if (buf->iSize / buf->uiNumElements != sizeof(VASliceParameterBufferHEVCExtension))
882 return VA_STATUS_ERROR_ALLOCATION_FAILED;
883
884 newSize = sizeof(VASliceParameterBufferHEVCExtension) * (m_sliceCtrlBufNum - availSize + buf->uiNumElements);
885 bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext= (VASliceParameterBufferHEVCExtension*)realloc(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext, newSize);
886 if(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext== nullptr)
887 {
888 return VA_STATUS_ERROR_ALLOCATION_FAILED;
889 }
890 MOS_ZeroMemory(bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext+ m_sliceCtrlBufNum, sizeof(VASliceParameterBufferHEVCExtension) * (buf->uiNumElements - availSize));
891 m_sliceCtrlBufNum = m_sliceCtrlBufNum - availSize + buf->uiNumElements;
892 }
893 buf->pData = (uint8_t*)bufMgr->Codec_Param.Codec_Param_HEVC.pVASliceParaBufHEVCRext;
894 buf->uiOffset = bufMgr->dwNumSliceControl * sizeof(VASliceParameterBufferHEVCExtension);
895 }
896 }
897
898 bufMgr->dwNumSliceControl += buf->uiNumElements;
899
900 return VA_STATUS_SUCCESS;
901 }
902
CodecHalInit(DDI_MEDIA_CONTEXT * mediaCtx,void * ptr)903 VAStatus DdiDecodeHEVCG12::CodecHalInit(
904 DDI_MEDIA_CONTEXT *mediaCtx,
905 void *ptr)
906 {
907 VAStatus vaStatus = VA_STATUS_SUCCESS;
908 MOS_CONTEXT *mosCtx = (MOS_CONTEXT *)ptr;
909
910 CODECHAL_FUNCTION codecFunction = CODECHAL_FUNCTION_DECODE;
911 m_ddiDecodeCtx->pCpDdiInterface->SetCpParams(m_ddiDecodeAttr->uiEncryptionType, m_codechalSettings);
912
913 CODECHAL_STANDARD_INFO standardInfo;
914 memset(&standardInfo, 0, sizeof(standardInfo));
915
916 standardInfo.CodecFunction = codecFunction;
917 standardInfo.Mode = (CODECHAL_MODE)m_ddiDecodeCtx->wMode;
918
919 m_codechalSettings->codecFunction = codecFunction;
920 m_codechalSettings->width = m_width;
921 m_codechalSettings->height = m_height;
922 m_codechalSettings->intelEntrypointInUse = false;
923
924 m_codechalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_8_BITS;
925 if (m_ddiDecodeAttr->profile == VAProfileHEVCMain10 ||
926 m_ddiDecodeAttr->profile == VAProfileHEVCMain422_10 ||
927 m_ddiDecodeAttr->profile == VAProfileHEVCMain444_10 ||
928 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain10 ||
929 m_ddiDecodeAttr->profile == VAProfileHEVCMain444_10)
930 {
931 m_codechalSettings->lumaChromaDepth |= CODECHAL_LUMA_CHROMA_DEPTH_10_BITS;
932 }
933
934 m_codechalSettings->shortFormatInUse = m_ddiDecodeCtx->bShortFormatInUse;
935
936 m_codechalSettings->mode = CODECHAL_DECODE_MODE_HEVCVLD;
937 m_codechalSettings->standard = CODECHAL_HEVC;
938 m_codechalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV420;
939
940 if(m_ddiDecodeAttr->profile == VAProfileHEVCMain422_10 ||
941 m_ddiDecodeAttr->profile == VAProfileHEVCMain422_12)
942 {
943 m_codechalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV422;
944 }
945
946 if(m_ddiDecodeAttr->profile == VAProfileHEVCMain444 ||
947 m_ddiDecodeAttr->profile == VAProfileHEVCMain444_10 ||
948 m_ddiDecodeAttr->profile == VAProfileHEVCMain444_12 ||
949 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444 ||
950 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444_10)
951 {
952 m_codechalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV444;
953 }
954
955 m_ddiDecodeCtx->DecodeParams.m_iqMatrixBuffer = MOS_AllocAndZeroMemory(sizeof(CODECHAL_HEVC_IQ_MATRIX_PARAMS));
956 if (m_ddiDecodeCtx->DecodeParams.m_iqMatrixBuffer == nullptr)
957 {
958 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
959 goto CleanUpandReturn;
960 }
961 m_ddiDecodeCtx->DecodeParams.m_picParams = MOS_AllocAndZeroMemory(sizeof(CODEC_HEVC_PIC_PARAMS));
962 if (m_ddiDecodeCtx->DecodeParams.m_picParams == nullptr)
963 {
964 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
965 goto CleanUpandReturn;
966 }
967 if(IsRextProfile())
968 {
969 m_ddiDecodeCtx->DecodeParams.m_extPicParams = MOS_AllocAndZeroMemory(sizeof(CODEC_HEVC_EXT_PIC_PARAMS));
970 if (m_ddiDecodeCtx->DecodeParams.m_extPicParams == nullptr)
971 {
972 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
973 goto CleanUpandReturn;
974 }
975
976 if(IsSccProfile())
977 {
978 m_ddiDecodeCtx->DecodeParams.m_advPicParams = MOS_AllocAndZeroMemory(sizeof(CODEC_HEVC_SCC_PIC_PARAMS));
979 if (m_ddiDecodeCtx->DecodeParams.m_advPicParams == nullptr)
980 {
981 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
982 goto CleanUpandReturn;
983 }
984 }
985 }
986
987 m_sliceParamBufNum = m_picHeightInMB;
988 m_ddiDecodeCtx->DecodeParams.m_sliceParams = MOS_AllocAndZeroMemory(m_sliceParamBufNum * sizeof(CODEC_HEVC_SLICE_PARAMS));
989 if (m_ddiDecodeCtx->DecodeParams.m_sliceParams == nullptr)
990 {
991 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
992 goto CleanUpandReturn;
993 }
994
995 if(IsRextProfile())
996 {
997 m_ddiDecodeCtx->DecodeParams.m_extSliceParams = MOS_AllocAndZeroMemory(m_sliceParamBufNum * sizeof(CODEC_HEVC_EXT_SLICE_PARAMS));
998 if (m_ddiDecodeCtx->DecodeParams.m_extSliceParams == nullptr)
999 {
1000 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
1001 goto CleanUpandReturn;
1002 }
1003 }
1004
1005 #ifdef _DECODE_PROCESSING_SUPPORTED
1006 if (m_decProcessingType == VA_DEC_PROCESSING)
1007 {
1008 DecodeProcessingParams *procParams = nullptr;
1009
1010 m_codechalSettings->downsamplingHinted = true;
1011
1012 procParams = (DecodeProcessingParams *)MOS_AllocAndZeroMemory(sizeof(DecodeProcessingParams));
1013 if (procParams == nullptr)
1014 {
1015 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
1016 goto CleanUpandReturn;
1017 }
1018
1019 m_ddiDecodeCtx->DecodeParams.m_procParams = procParams;
1020 procParams->m_outputSurface = (PMOS_SURFACE)MOS_AllocAndZeroMemory(sizeof(MOS_SURFACE));
1021 if (procParams->m_outputSurface == nullptr)
1022 {
1023 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
1024 goto CleanUpandReturn;
1025 }
1026 }
1027 #endif
1028
1029 vaStatus = CreateCodecHal(mediaCtx,
1030 ptr,
1031 &standardInfo);
1032
1033 if (vaStatus != VA_STATUS_SUCCESS)
1034 {
1035 goto CleanUpandReturn;
1036 }
1037
1038 if (InitResourceBuffer() != VA_STATUS_SUCCESS)
1039 {
1040 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
1041 goto CleanUpandReturn;
1042 }
1043
1044 return vaStatus;
1045
1046 CleanUpandReturn:
1047 FreeResourceBuffer();
1048
1049 if (m_ddiDecodeCtx->pCodecHal)
1050 {
1051 m_ddiDecodeCtx->pCodecHal->Destroy();
1052 MOS_Delete(m_ddiDecodeCtx->pCodecHal);
1053 m_ddiDecodeCtx->pCodecHal = nullptr;
1054 }
1055
1056 MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_iqMatrixBuffer);
1057 m_ddiDecodeCtx->DecodeParams.m_iqMatrixBuffer = nullptr;
1058 MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_picParams);
1059 m_ddiDecodeCtx->DecodeParams.m_picParams = nullptr;
1060 MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_huffmanTable);
1061 m_ddiDecodeCtx->DecodeParams.m_huffmanTable = nullptr;
1062 MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_sliceParams);
1063 m_ddiDecodeCtx->DecodeParams.m_sliceParams = nullptr;
1064
1065 #ifdef _DECODE_PROCESSING_SUPPORTED
1066 if (m_ddiDecodeCtx->DecodeParams.m_procParams)
1067 {
1068 auto procParams =
1069 (DecodeProcessingParams *)m_ddiDecodeCtx->DecodeParams.m_procParams;
1070 MOS_FreeMemory(procParams->m_outputSurface);
1071
1072 MOS_FreeMemory(m_ddiDecodeCtx->DecodeParams.m_procParams);
1073 m_ddiDecodeCtx->DecodeParams.m_procParams = nullptr;
1074 }
1075 #endif
1076 return vaStatus;
1077 }
1078
IsRextProfile()1079 bool DdiDecodeHEVCG12::IsRextProfile()
1080 {
1081 return ( \
1082 m_ddiDecodeAttr->profile == VAProfileHEVCMain12 || \
1083 m_ddiDecodeAttr->profile == VAProfileHEVCMain422_10 || \
1084 m_ddiDecodeAttr->profile == VAProfileHEVCMain422_12 || \
1085 m_ddiDecodeAttr->profile == VAProfileHEVCMain444 || \
1086 m_ddiDecodeAttr->profile == VAProfileHEVCMain444_10 || \
1087 m_ddiDecodeAttr->profile == VAProfileHEVCMain444_12 || \
1088 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain || \
1089 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain10 || \
1090 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444 || \
1091 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444_10 \
1092 );
1093 }
1094
IsSccProfile()1095 bool DdiDecodeHEVCG12::IsSccProfile()
1096 {
1097 return ( \
1098 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain || \
1099 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain10 || \
1100 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444 || \
1101 m_ddiDecodeAttr->profile == VAProfileHEVCSccMain444_10 \
1102 );
1103 }
1104
1105
1106 extern template class MediaDdiFactory<DdiMediaDecode, DDI_DECODE_CONFIG_ATTR>;
1107
1108 static bool hevcRegistered =
1109 MediaDdiFactory<DdiMediaDecode, DDI_DECODE_CONFIG_ATTR>::RegisterCodec<DdiDecodeHEVCG12>(DECODE_ID_HEVC_G12);
1110