Debian Codegraph @

media_driver/agnostic/gen9_bxt/hw/vdbox/mhw_vdbox_hcp_g9_bxt.cpp

raw
1 /*
2 * Copyright (c) 2017, 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 mhw_vdbox_hcp_g9_bxt.cpp
24 //! \brief Defines functions for constructing Vdbox HCP commands on G9 BXT platform
25 //!
26
27 #include "mos_os_cp_interface_specific.h"
28 #include "mhw_vdbox_hcp_g9_bxt.h"
29 #include "mhw_mi_hwcmd_g9_X.h"
30 #include "mhw_vdbox_vdenc_hwcmd_g9_bxt.h"
31
32 void MhwVdboxHcpInterfaceG9Bxt::InitRowstoreUserFeatureSettings()
33 {
34 MhwVdboxHcpInterfaceG9::InitRowstoreUserFeatureSettings(m_osInterface->pOsContext);
35
36 if (m_rowstoreCachingSupported && m_decodeInUse)
37 {
38 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
39
40 PLATFORM platform;
41 m_osInterface->pfnGetPlatform(m_osInterface, &platform);
42
43 if (platform.usRevId >= 3)
44 {
45 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
46 #if (_DEBUG || _RELEASE_INTERNAL)
47 MOS_UserFeature_ReadValue_ID(
48 nullptr,
49 __MEDIA_USER_FEATURE_VALUE_VP9_HVDROWSTORECACHE_DISABLE_ID,
50 &userFeatureData,
51 m_osInterface->pOsContext);
52 #endif // _DEBUG || _RELEASE_INTERNAL
53 m_vp9HvdRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
54
55 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
56 #if (_DEBUG || _RELEASE_INTERNAL)
57 MOS_UserFeature_ReadValue_ID(
58 nullptr,
59 __MEDIA_USER_FEATURE_VALUE_VP9_DFROWSTORECACHE_DISABLE_ID,
60 &userFeatureData,
61 m_osInterface->pOsContext);
62 #endif // _DEBUG || _RELEASE_INTERNAL
63 m_vp9DfRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
64 }
65 }
66 }
67
68 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::GetHcpStateCommandSize(
69 uint32_t mode,
70 uint32_t *commandsSize,
71 uint32_t *patchListSize,
72 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
73 {
74 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
75
76 MHW_FUNCTION_ENTER;
77
78 uint32_t maxSize = 0;
79 uint32_t patchListMaxSize = 0;
80 uint32_t standard = CodecHal_GetStandardFromMode(mode);
81
82 if (standard == CODECHAL_HEVC)
83 {
84 maxSize =
85 mhw_vdbox_vdenc_g9_bxt::VD_PIPELINE_FLUSH_CMD::byteSize +
86 mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize +
87 mhw_vdbox_hcp_g9_bxt::HCP_PIPE_MODE_SELECT_CMD::byteSize +
88 mhw_vdbox_hcp_g9_bxt::HCP_SURFACE_STATE_CMD::byteSize +
89 mhw_vdbox_hcp_g9_bxt::HCP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
90 mhw_vdbox_hcp_g9_bxt::HCP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize;
91
92 patchListMaxSize =
93 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD) +
94 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
95 PATCH_LIST_COMMAND(HCP_PIPE_MODE_SELECT_CMD) +
96 PATCH_LIST_COMMAND(HCP_SURFACE_STATE_CMD) +
97 PATCH_LIST_COMMAND(HCP_PIPE_BUF_ADDR_STATE_CMD) +
98 PATCH_LIST_COMMAND(HCP_IND_OBJ_BASE_ADDR_STATE_CMD);
99
100 if (mode == CODECHAL_ENCODE_MODE_HEVC)
101 {
102 /* HCP_QM_STATE_CMD may be issued up to 20 times: 3x Colour Component plus 2x intra/inter plus 4x SizeID minus 4 for the 32x32 chroma components.
103 HCP_FQP_STATE_CMD may be issued up to 8 times: 4 scaling list per intra and inter. */
104 maxSize +=
105 mhw_vdbox_hcp_g9_bxt::HCP_SURFACE_STATE_CMD::byteSize + // encoder needs two surface state commands. One is for raw and another one is for recon surfaces.
106 20 * mhw_vdbox_hcp_g9_bxt::HCP_QM_STATE_CMD::byteSize +
107 8 * mhw_vdbox_hcp_g9_bxt::HCP_FQM_STATE_CMD::byteSize +
108 mhw_vdbox_hcp_g9_bxt::HCP_PIC_STATE_CMD::byteSize +
109 2 * mhw_mi_g9_X::MI_STORE_DATA_IMM_CMD::byteSize + // Slice level commands
110 2 * mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize + // need for Status report, Mfc Status and
111 10 * mhw_mi_g9_X::MI_STORE_REGISTER_MEM_CMD::byteSize + // 8 for BRCStatistics and 2 for RC6 WAs
112 mhw_mi_g9_X::MI_LOAD_REGISTER_MEM_CMD::byteSize + // 1 for RC6
113 2 * mhw_vdbox_hcp_g9_bxt::HCP_PAK_INSERT_OBJECT_CMD::byteSize; // Two PAK insert object commands are for headers before the slice header and the header for the end of stream
114
115 patchListMaxSize +=
116 20 * PATCH_LIST_COMMAND(HCP_QM_STATE_CMD) +
117 8 * PATCH_LIST_COMMAND(HCP_FQM_STATE_CMD) +
118 PATCH_LIST_COMMAND(HCP_PIC_STATE_CMD) +
119 PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD) + // When BRC is on, HCP_PIC_STATE_CMD command is in the BB
120 2 * PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD) + // Slice level commands
121 2 * PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) + // need for Status report, Mfc Status and
122 11 * PATCH_LIST_COMMAND(MI_STORE_REGISTER_MEM_CMD); // 8 for BRCStatistics and 3 for RC6 WAs
123 }
124 else
125 {
126 maxSize +=
127 20 * mhw_vdbox_hcp_g9_bxt::HCP_QM_STATE_CMD::byteSize +
128 mhw_vdbox_hcp_g9_bxt::HCP_PIC_STATE_CMD::byteSize +
129 mhw_vdbox_hcp_g9_bxt::HCP_TILE_STATE_CMD::byteSize;
130
131 patchListMaxSize +=
132 20 * PATCH_LIST_COMMAND(HCP_QM_STATE_CMD) +
133 PATCH_LIST_COMMAND(HCP_PIC_STATE_CMD) +
134 PATCH_LIST_COMMAND(HCP_TILE_STATE_CMD);
135 }
136 }
137 else if (standard == CODECHAL_VP9) // VP9 Clear Decode
138 {
139 maxSize =
140 mhw_vdbox_vdenc_g9_bxt::VD_PIPELINE_FLUSH_CMD::byteSize +
141 mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize +
142 mhw_vdbox_hcp_g9_bxt::HCP_PIPE_MODE_SELECT_CMD::byteSize +
143 mhw_vdbox_hcp_g9_bxt::HCP_SURFACE_STATE_CMD::byteSize * 4 +
144 mhw_vdbox_hcp_g9_bxt::HCP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
145 mhw_vdbox_hcp_g9_bxt::HCP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
146 mhw_vdbox_hcp_g9_bxt::HCP_VP9_SEGMENT_STATE_CMD::byteSize * 8 +
147 mhw_vdbox_hcp_g9_bxt::HCP_VP9_PIC_STATE_CMD::byteSize +
148 mhw_vdbox_hcp_g9_bxt::HCP_BSD_OBJECT_CMD::byteSize;
149
150 patchListMaxSize =
151 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD) +
152 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
153 PATCH_LIST_COMMAND(HCP_PIPE_MODE_SELECT_CMD) +
154 PATCH_LIST_COMMAND(HCP_SURFACE_STATE_CMD) * 4 +
155 PATCH_LIST_COMMAND(HCP_PIPE_BUF_ADDR_STATE_CMD) +
156 PATCH_LIST_COMMAND(HCP_IND_OBJ_BASE_ADDR_STATE_CMD) +
157 PATCH_LIST_COMMAND(HCP_VP9_SEGMENT_STATE_CMD) * 8 +
158 PATCH_LIST_COMMAND(HCP_VP9_PIC_STATE_CMD) +
159 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
160 }
161 else
162 {
163 MHW_ASSERTMESSAGE("Unsupported standard.");
164 eStatus = MOS_STATUS_UNKNOWN;
165 }
166
167 *commandsSize = maxSize;
168 *patchListSize = patchListMaxSize;
169
170 return eStatus;
171 }
172
173 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::GetHcpPrimitiveCommandSize(
174 uint32_t mode,
175 uint32_t *commandsSize,
176 uint32_t *patchListSize,
177 bool modeSpecific)
178 {
179 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
180
181 MHW_FUNCTION_ENTER;
182
183 uint32_t standard = CodecHal_GetStandardFromMode(mode);
184 uint32_t maxSize = 0;
185 uint32_t patchListMaxSize = 0;
186
187 if (standard == CODECHAL_HEVC)
188 {
189 if (mode == CODECHAL_ENCODE_MODE_HEVC)
190 {
191 maxSize =
192 2 * mhw_vdbox_hcp_g9_bxt::HCP_REF_IDX_STATE_CMD::byteSize +
193 2 * mhw_vdbox_hcp_g9_bxt::HCP_WEIGHTOFFSET_STATE_CMD::byteSize +
194 mhw_vdbox_hcp_g9_bxt::HCP_SLICE_STATE_CMD::byteSize +
195 mhw_vdbox_hcp_g9_bxt::HCP_PAK_INSERT_OBJECT_CMD::byteSize +
196 mhw_mi_g9_X::MI_BATCH_BUFFER_START_CMD::byteSize;
197
198 patchListMaxSize =
199 2 * PATCH_LIST_COMMAND(HCP_REF_IDX_STATE_CMD) +
200 2 * PATCH_LIST_COMMAND(HCP_WEIGHTOFFSET_STATE_CMD) +
201 PATCH_LIST_COMMAND(HCP_SLICE_STATE_CMD) +
202 PATCH_LIST_COMMAND(HCP_PAK_INSERT_OBJECT_CMD) +
203 2 * PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD); // One is for the PAK command and another one is for the BB when BRC and single task mode are on
204
205 }
206 else
207 {
208 maxSize =
209 2 * mhw_vdbox_hcp_g9_bxt::HCP_REF_IDX_STATE_CMD::byteSize +
210 2 * mhw_vdbox_hcp_g9_bxt::HCP_WEIGHTOFFSET_STATE_CMD::byteSize +
211 mhw_vdbox_hcp_g9_bxt::HCP_SLICE_STATE_CMD::byteSize +
212 mhw_vdbox_hcp_g9_bxt::HCP_BSD_OBJECT_CMD::byteSize +
213 mhw_mi_g9_X::MI_BATCH_BUFFER_END_CMD::byteSize;
214
215 patchListMaxSize =
216 2 * PATCH_LIST_COMMAND(HCP_REF_IDX_STATE_CMD) +
217 2 * PATCH_LIST_COMMAND(HCP_WEIGHTOFFSET_STATE_CMD) +
218 PATCH_LIST_COMMAND(HCP_SLICE_STATE_CMD) +
219 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
220 }
221 }
222 else if (standard == CODECHAL_VP9) // VP9 Clear decode does not require primitive level commands. VP9 DRM does.
223 {
224 if (modeSpecific) // VP9 DRM
225 {
226 maxSize +=
227 mhw_vdbox_hcp_g9_bxt::HCP_VP9_SEGMENT_STATE_CMD::byteSize * 8 +
228 mhw_vdbox_hcp_g9_bxt::HCP_VP9_PIC_STATE_CMD::byteSize +
229 mhw_vdbox_hcp_g9_bxt::HCP_BSD_OBJECT_CMD::byteSize +
230 mhw_mi_g9_X::MI_BATCH_BUFFER_END_CMD::byteSize;
231
232 patchListMaxSize =
233 PATCH_LIST_COMMAND(HCP_VP9_SEGMENT_STATE_CMD) * 8 +
234 PATCH_LIST_COMMAND(HCP_VP9_PIC_STATE_CMD) +
235 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
236 }
237 }
238 else
239 {
240 MHW_ASSERTMESSAGE("Unsupported standard.");
241 eStatus = MOS_STATUS_UNKNOWN;
242 }
243
244 *commandsSize = maxSize;
245 *patchListSize = patchListMaxSize;
246
247 return eStatus;
248 }
249
250 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::AddHcpPipeModeSelectCmd(
251 PMOS_COMMAND_BUFFER cmdBuffer,
252 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
253 {
254 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
255
256 MHW_FUNCTION_ENTER;
257
258 MHW_MI_CHK_NULL(params);
259
260 mhw_vdbox_hcp_g9_bxt::HCP_PIPE_MODE_SELECT_CMD *cmd =
261 (mhw_vdbox_hcp_g9_bxt::HCP_PIPE_MODE_SELECT_CMD*)cmdBuffer->pCmdPtr;
262
263 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceG9<mhw_vdbox_hcp_g9_bxt>::AddHcpPipeModeSelectCmd(cmdBuffer, params));
264
265 m_cpInterface->SetProtectionSettingsForHcpPipeModeSelect((uint32_t *)cmd);
266
267 return eStatus;
268 }
269
270 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::AddHcpDecodeSurfaceStateCmd(
271 PMOS_COMMAND_BUFFER cmdBuffer,
272 PMHW_VDBOX_SURFACE_PARAMS params)
273 {
274 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
275
276 MHW_MI_CHK_NULL(params);
277
278 mhw_vdbox_hcp_g9_bxt::HCP_SURFACE_STATE_CMD *cmd =
279 (mhw_vdbox_hcp_g9_bxt::HCP_SURFACE_STATE_CMD*)cmdBuffer->pCmdPtr;
280
281 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_bxt>::AddHcpDecodeSurfaceStateCmd(cmdBuffer, params));
282
283 if (params->ucBitDepthLumaMinus8 == 0 && params->ucBitDepthChromaMinus8 == 0)
284 {
285 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_PLANAR_420_8;
286 }
287 else
288 {
289 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_P010;
290 }
291
292 return eStatus;
293 }
294
295 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::AddHcpEncodeSurfaceStateCmd(
296 PMOS_COMMAND_BUFFER cmdBuffer,
297 PMHW_VDBOX_SURFACE_PARAMS params)
298 {
299 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
300
301 MHW_MI_CHK_NULL(params);
302
303 mhw_vdbox_hcp_g9_bxt::HCP_SURFACE_STATE_CMD *cmd =
304 (mhw_vdbox_hcp_g9_bxt::HCP_SURFACE_STATE_CMD*)cmdBuffer->pCmdPtr;
305
306 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_bxt>::AddHcpEncodeSurfaceStateCmd(cmdBuffer, params));
307
308 if (params->ucBitDepthLumaMinus8 == 0 && params->ucBitDepthChromaMinus8 == 0)
309 {
310 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_PLANAR_420_8;
311 }
312 else
313 {
314 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_P010;
315 }
316
317 return eStatus;
318 }
319
320 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::AddHcpDecodePicStateCmd(
321 PMOS_COMMAND_BUFFER cmdBuffer,
322 PMHW_VDBOX_HEVC_PIC_STATE params)
323 {
324 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
325
326 MHW_FUNCTION_ENTER;
327
328 MHW_MI_CHK_NULL(params);
329 MHW_MI_CHK_NULL(params->pHevcPicParams);
330
331 mhw_vdbox_hcp_g9_bxt::HCP_PIC_STATE_CMD *cmd =
332 (mhw_vdbox_hcp_g9_bxt::HCP_PIC_STATE_CMD*)cmdBuffer->pCmdPtr;
333
334 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_bxt>::AddHcpDecodePicStateCmd(cmdBuffer, params));
335
336 auto hevcPicParams = params->pHevcPicParams;
337 PLATFORM platform;
338 m_osInterface->pfnGetPlatform(m_osInterface, &platform);
339
340 // HCP is changed from B-STEPPING for HEVC MAIN 10 decode
341 if (platform.usRevId > 2)
342 {
343 cmd->DW5.BitDepthChromaMinus8 = hevcPicParams->bit_depth_chroma_minus8;
344 cmd->DW5.BitDepthLumaMinus8 = hevcPicParams->bit_depth_luma_minus8;
345 }
346
347 return eStatus;
348 }
349
350 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::AddHcpDecodeSliceStateCmd(
351 PMOS_COMMAND_BUFFER cmdBuffer,
352 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
353 {
354 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
355
356 MHW_FUNCTION_ENTER;
357
358 MHW_MI_CHK_NULL(hevcSliceState);
359 MHW_MI_CHK_NULL(hevcSliceState->pHevcPicParams);
360 MHW_MI_CHK_NULL(hevcSliceState->pHevcSliceParams);
361
362 auto hevcPicParams = hevcSliceState->pHevcPicParams;
363 auto hevcSliceParams = hevcSliceState->pHevcSliceParams;
364
365 mhw_vdbox_hcp_g9_bxt::HCP_SLICE_STATE_CMD *cmd =
366 (mhw_vdbox_hcp_g9_bxt::HCP_SLICE_STATE_CMD*)cmdBuffer->pCmdPtr;
367
368 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_bxt>::AddHcpDecodeSliceStateCmd(cmdBuffer, hevcSliceState));
369
370 PLATFORM platform;
371 m_osInterface->pfnGetPlatform(m_osInterface, &platform);
372
373 // HCP is changed from B-STEPPING for HEVC MAIN 10 decode
374 if (platform.usRevId > 2)
375 {
376 int32_t sliceQP = hevcSliceParams->slice_qp_delta + hevcPicParams->init_qp_minus26 + 26;
377 cmd->DW3.SliceqpSignFlag = (sliceQP >= 0) ? 0 : 1;
378 cmd->DW3.Sliceqp = ABS(sliceQP);
379 }
380 else
381 {
382 cmd->DW3.Sliceqp = hevcSliceParams->slice_qp_delta +
383 hevcPicParams->init_qp_minus26 + 26;
384 }
385
386 return eStatus;
387 }
388
389 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::AddHcpVp9PicStateCmd(
390 PMOS_COMMAND_BUFFER cmdBuffer,
391 PMHW_BATCH_BUFFER batchBuffer,
392 PMHW_VDBOX_VP9_PIC_STATE params)
393 {
394 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
395
396 MHW_MI_CHK_NULL(params);
397 MHW_MI_CHK_NULL(params->pVp9PicParams);
398
399 mhw_vdbox_hcp_g9_bxt::HCP_VP9_PIC_STATE_CMD cmd;
400 auto vp9PicParams = params->pVp9PicParams;
401 auto vp9RefList = params->ppVp9RefList;
402
403 uint32_t curFrameWidth = vp9PicParams->FrameWidthMinus1 + 1;
404 uint32_t curFrameHeight = vp9PicParams->FrameHeightMinus1 + 1;
405 bool isScaling = (curFrameWidth == params->dwPrevFrmWidth) && (curFrameHeight == params->dwPrevFrmHeight) ? false : true;
406
407 cmd.DW1.FrameWidthInPixelsMinus1 = MOS_ALIGN_CEIL(curFrameWidth, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
408 cmd.DW1.FrameHeightInPixelsMinus1 = MOS_ALIGN_CEIL(curFrameHeight, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
409
410 cmd.DW2.FrameType = vp9PicParams->PicFlags.fields.frame_type;
411 cmd.DW2.AdaptProbabilitiesFlag = !vp9PicParams->PicFlags.fields.error_resilient_mode && !vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
412 cmd.DW2.IntraonlyFlag = vp9PicParams->PicFlags.fields.intra_only;
413 cmd.DW2.RefreshFrameContext = vp9PicParams->PicFlags.fields.refresh_frame_context;
414 cmd.DW2.ErrorResilientMode = vp9PicParams->PicFlags.fields.error_resilient_mode;
415 cmd.DW2.FrameParallelDecodingMode = vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
416 cmd.DW2.FilterLevel = vp9PicParams->filter_level;
417 cmd.DW2.SharpnessLevel = vp9PicParams->sharpness_level;
418 cmd.DW2.SegmentationEnabled = vp9PicParams->PicFlags.fields.segmentation_enabled;
419 cmd.DW2.SegmentationUpdateMap = cmd.DW2.SegmentationEnabled && vp9PicParams->PicFlags.fields.segmentation_update_map;
420 cmd.DW2.LosslessMode = vp9PicParams->PicFlags.fields.LosslessFlag;
421 cmd.DW2.SegmentIdStreamoutEnable = cmd.DW2.SegmentationUpdateMap;
422
423 uint8_t segmentIDStreaminEnable = 0;
424 if (vp9PicParams->PicFlags.fields.intra_only ||
425 (vp9PicParams->PicFlags.fields.frame_type == CODEC_VP9_KEY_FRAME)) {
426 segmentIDStreaminEnable = 1;
427 } else if (vp9PicParams->PicFlags.fields.segmentation_enabled) {
428 if (!vp9PicParams->PicFlags.fields.segmentation_update_map)
429 segmentIDStreaminEnable = 1;
430 else if (vp9PicParams->PicFlags.fields.segmentation_temporal_update)
431 segmentIDStreaminEnable = 1;
432 }
433 if (vp9PicParams->PicFlags.fields.error_resilient_mode) {
434 segmentIDStreaminEnable = 1;
435 }
436 // Resolution change will reset the segment ID buffer
437 if (isScaling)
438 {
439 segmentIDStreaminEnable = 1;
440 }
441
442 cmd.DW2.SegmentIdStreaminEnable = segmentIDStreaminEnable;
443
444 cmd.DW3.Log2TileRow = vp9PicParams->log2_tile_rows; // No need to minus 1 here.
445 cmd.DW3.Log2TileColumn = vp9PicParams->log2_tile_columns; // No need to minus 1 here.
446
447 cmd.DW10.UncompressedHeaderLengthInBytes70 = vp9PicParams->UncompressedHeaderLengthInBytes;
448 cmd.DW10.FirstPartitionSizeInBytes150 = vp9PicParams->FirstPartitionSize;
449
450 if (vp9PicParams->PicFlags.fields.frame_type && !vp9PicParams->PicFlags.fields.intra_only)
451 {
452 PCODEC_PICTURE refFrameList = &(vp9PicParams->RefFrameList[0]);
453
454 uint8_t lastRefPicIndex = refFrameList[vp9PicParams->PicFlags.fields.LastRefIdx].FrameIdx;
455 uint32_t lastRefFrameWidth = vp9RefList[lastRefPicIndex]->dwFrameWidth;
456 uint32_t lastRefFrameHeight = vp9RefList[lastRefPicIndex]->dwFrameHeight;
457
458 uint8_t goldenRefPicIndex = refFrameList[vp9PicParams->PicFlags.fields.GoldenRefIdx].FrameIdx;
459 uint32_t goldenRefFrameWidth = vp9RefList[goldenRefPicIndex]->dwFrameWidth;
460 uint32_t goldenRefFrameHeight = vp9RefList[goldenRefPicIndex]->dwFrameHeight;
461
462 uint8_t altRefPicIndex = refFrameList[vp9PicParams->PicFlags.fields.AltRefIdx].FrameIdx;
463 uint32_t altRefFrameWidth = vp9RefList[altRefPicIndex]->dwFrameWidth;
464 uint32_t altRefFrameHeight = vp9RefList[altRefPicIndex]->dwFrameHeight;
465
466 cmd.DW2.AllowHiPrecisionMv = vp9PicParams->PicFlags.fields.allow_high_precision_mv;
467 cmd.DW2.McompFilterType = vp9PicParams->PicFlags.fields.mcomp_filter_type;
468 cmd.DW2.SegmentationTemporalUpdate = cmd.DW2.SegmentationUpdateMap && vp9PicParams->PicFlags.fields.segmentation_temporal_update;
469
470 cmd.DW2.RefFrameSignBias02 = vp9PicParams->PicFlags.fields.LastRefSignBias |
471 (vp9PicParams->PicFlags.fields.GoldenRefSignBias << 1) |
472 (vp9PicParams->PicFlags.fields.AltRefSignBias << 2);
473
474 cmd.DW2.LastFrameType = !params->PrevFrameParams.fields.KeyFrame;
475
476 // Reset UsePrevInFindMvReferences to zero if last picture has a different size,
477 // Current picture is error-resilient mode, Last picture was intra_only or keyframe,
478 // Last picture was not a displayed picture.
479 cmd.DW2.UsePrevInFindMvReferences =
480 !(vp9PicParams->PicFlags.fields.error_resilient_mode ||
481 params->PrevFrameParams.fields.KeyFrame ||
482 params->PrevFrameParams.fields.IntraOnly ||
483 !params->PrevFrameParams.fields.Display);
484 // Reset UsePrevInFindMvReferences in case of resolution change on inter frames
485 if (isScaling) {
486 cmd.DW2.UsePrevInFindMvReferences = 0;
487 }
488
489 cmd.DW4.HorizontalScaleFactorForLast = (lastRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
490 cmd.DW4.VerticalScaleFactorForLast = (lastRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
491
492 cmd.DW5.HorizontalScaleFactorForGolden = (goldenRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
493 cmd.DW5.VerticalScaleFactorForGolden = (goldenRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
494
495 cmd.DW6.HorizontalScaleFactorForAltref = (altRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
496 cmd.DW6.VerticalScaleFactorForAltref = (altRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
497
498 cmd.DW7.LastFrameWidthInPixelsMinus1 = lastRefFrameWidth - 1;
499 cmd.DW7.LastFrameHieghtInPixelsMinus1 = lastRefFrameHeight - 1;
500
501 cmd.DW8.GoldenFrameWidthInPixelsMinus1 = goldenRefFrameWidth - 1;
502 cmd.DW8.GoldenFrameHieghtInPixelsMinus1 = goldenRefFrameHeight - 1;
503
504 cmd.DW9.AltrefFrameWidthInPixelsMinus1 = altRefFrameWidth - 1;
505 cmd.DW9.AltrefFrameHieghtInPixelsMinus1 = altRefFrameHeight - 1;
506 }
507
508 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, cmd.byteSize));
509
510 return eStatus;
511 }
512
513 MOS_STATUS MhwVdboxHcpInterfaceG9Bxt::AddHcpVp9SegmentStateCmd(
514 PMOS_COMMAND_BUFFER cmdBuffer,
515 PMHW_BATCH_BUFFER batchBuffer,
516 PMHW_VDBOX_VP9_SEGMENT_STATE params)
517 {
518 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
519
520 MHW_MI_CHK_NULL(params);
521
522 mhw_vdbox_hcp_g9_bxt::HCP_VP9_SEGMENT_STATE_CMD cmd;
523 void* segData = nullptr;
524
525 cmd.DW1.SegmentId = params->ucCurrentSegmentId;
526
527 if (!this->m_decodeInUse)
528 {
529 CODEC_VP9_ENCODE_SEG_PARAMS vp9SegData;
530
531 vp9SegData = params->pVp9EncodeSegmentParams->SegData[params->ucCurrentSegmentId];
532
533 if (params->pbSegStateBufferPtr) // Use the seg data from this buffer (output of BRC)
534 {
535 segData = params->pbSegStateBufferPtr;
536 }
537 else // Prepare the seg data
538 {
539 cmd.DW2.SegmentSkipped = vp9SegData.SegmentFlags.fields.SegmentSkipped;
540 cmd.DW2.SegmentReference = vp9SegData.SegmentFlags.fields.SegmentReference;
541 cmd.DW2.SegmentReferenceEnabled = vp9SegData.SegmentFlags.fields.SegmentReferenceEnabled;
542
543 segData = &cmd;
544 }
545 }
546 else
547 {
548 CODEC_VP9_SEG_PARAMS vp9SegData;
549 vp9SegData = params->pVp9SegmentParams->SegData[params->ucCurrentSegmentId];
550
551 cmd.DW2.SegmentSkipped = vp9SegData.SegmentFlags.fields.SegmentReferenceSkipped;
552 cmd.DW2.SegmentReference = vp9SegData.SegmentFlags.fields.SegmentReference;
553 cmd.DW2.SegmentReferenceEnabled = vp9SegData.SegmentFlags.fields.SegmentReferenceEnabled;
554
555 cmd.DW3.Filterlevelref0Mode0 = vp9SegData.FilterLevel[0][0];
556 cmd.DW3.Filterlevelref0Mode1 = vp9SegData.FilterLevel[0][1];
557 cmd.DW3.Filterlevelref1Mode0 = vp9SegData.FilterLevel[1][0];
558 cmd.DW3.Filterlevelref1Mode1 = vp9SegData.FilterLevel[1][1];
559
560 cmd.DW4.Filterlevelref2Mode0 = vp9SegData.FilterLevel[2][0];
561 cmd.DW4.Filterlevelref2Mode1 = vp9SegData.FilterLevel[2][1];
562 cmd.DW4.Filterlevelref3Mode0 = vp9SegData.FilterLevel[3][0];
563 cmd.DW4.Filterlevelref3Mode1 = vp9SegData.FilterLevel[3][1];
564
565 cmd.DW5.LumaDcQuantScaleDecodeModeOnly = vp9SegData.LumaDCQuantScale;
566 cmd.DW5.LumaAcQuantScaleDecodeModeOnly = vp9SegData.LumaACQuantScale;
567
568 cmd.DW6.ChromaDcQuantScaleDecodeModeOnly = vp9SegData.ChromaDCQuantScale;
569 cmd.DW6.ChromaAcQuantScaleDecodeModeOnly = vp9SegData.ChromaACQuantScale;
570
571 segData = &cmd;
572 }
573
574 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, segData, cmd.byteSize));
575
576 return eStatus;
577 }