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_mfx_g9_skl.cpp
24 //! \brief Defines functions for constructing Vdbox MFX commands on G9 SKL
25 //!
26
27 #include "mhw_vdbox_mfx_g9_skl.h"
28
AddMfxPipeBufAddrCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)29 MOS_STATUS MhwVdboxMfxInterfaceG9Skl::AddMfxPipeBufAddrCmd(
30 PMOS_COMMAND_BUFFER cmdBuffer,
31 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)
32 {
33 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
34
35 MHW_FUNCTION_ENTER;
36
37 MHW_MI_CHK_NULL(cmdBuffer);
38 MHW_MI_CHK_NULL(params);
39
40 MHW_RESOURCE_PARAMS resourceParams;
41 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
42 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
43 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
44
45 mhw_vdbox_mfx_g9_skl::MFX_PIPE_BUF_ADDR_STATE_CMD cmd;
46
47 #if (_DEBUG || _RELEASE_INTERNAL)
48 MOS_USER_FEATURE_VALUE_WRITE_DATA UserFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
49 UserFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED_ID;
50 if (m_intraRowstoreCache.bEnabled ||
51 m_deblockingFilterRowstoreCache.bEnabled ||
52 m_bsdMpcRowstoreCache.bEnabled ||
53 m_mprRowstoreCache.bEnabled)
54 {
55 UserFeatureWriteData.Value.i32Data = 1;
56 }
57 MOS_UserFeature_WriteValues_ID(nullptr, &UserFeatureWriteData, 1);
58 #endif
59
60 // Encoding uses both surfaces regardless of deblocking status
61 if (params->psPreDeblockSurface != nullptr)
62 {
63 cmd.DW3.MemoryObjectControlState =
64 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Value;
65 cmd.DW3.PreDeblockingMemoryCompressionEnable = (params->PreDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ?
66 MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
67 cmd.DW3.PreDeblockingMemoryCompressionMode = (params->PreDeblockSurfMmcState == MOS_MEMCOMP_HORIZONTAL) ?
68 MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
69
70 cmd.DW3.PreDeblockingTiledResourceMode = Mhw_ConvertToTRMode(params->psPreDeblockSurface->TileType);
71
72 resourceParams.presResource = &(params->psPreDeblockSurface->OsResource);
73 resourceParams.dwOffset = params->psPreDeblockSurface->dwOffset;
74 resourceParams.pdwCmd = &(cmd.DW1.Value);
75 resourceParams.dwLocationInCmd = 1;
76 resourceParams.bIsWritable = true;
77
78 MHW_MI_CHK_STATUS(AddResourceToCmd(
79 m_osInterface,
80 cmdBuffer,
81 &resourceParams));
82
83 MHW_MI_CHK_STATUS(m_osInterface->pfnSetMemoryCompressionMode(m_osInterface, resourceParams.presResource, params->PreDeblockSurfMmcState));
84 }
85
86 if (params->psPostDeblockSurface != nullptr)
87 {
88 cmd.DW6.MemoryObjectControlState =
89 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC].Value;
90 cmd.DW6.PostDeblockingMemoryCompressionEnable = (params->PostDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ?
91 MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
92 cmd.DW6.PostDeblockingMemoryCompressionMode = (params->PostDeblockSurfMmcState == MOS_MEMCOMP_HORIZONTAL) ?
93 MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
94
95 cmd.DW6.PostDeblockingTiledResourceMode = Mhw_ConvertToTRMode(params->psPostDeblockSurface->TileType);
96
97 resourceParams.presResource = &(params->psPostDeblockSurface->OsResource);
98 resourceParams.dwOffset = params->psPostDeblockSurface->dwOffset;
99 resourceParams.pdwCmd = &(cmd.DW4.Value);
100 resourceParams.dwLocationInCmd = 4;
101 resourceParams.bIsWritable = true;
102
103 MHW_MI_CHK_STATUS(AddResourceToCmd(
104 m_osInterface,
105 cmdBuffer,
106 &resourceParams));
107
108 MHW_MI_CHK_STATUS(m_osInterface->pfnSetMemoryCompressionMode(m_osInterface, resourceParams.presResource, params->PostDeblockSurfMmcState));
109 }
110
111 if (params->psRawSurface != nullptr)
112 {
113 if (!m_decodeInUse)
114 {
115 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
116 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, ¶ms->psRawSurface->OsResource, &mmcMode));
117
118 cmd.DW9.MemoryObjectControlState =
119 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
120 cmd.DW9.OriginalUncompressedPictureMemoryCompressionEnable =
121 mmcMode != MOS_MEMCOMP_DISABLED ? MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
122 cmd.DW9.OriginalUncompressedPictureMemoryCompressionMode =
123 mmcMode == MOS_MEMCOMP_HORIZONTAL ? MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
124 }
125 else
126 {
127 cmd.DW9.MemoryObjectControlState =
128 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE].Value;
129 }
130
131 cmd.DW9.OriginalUncompressedPictureTiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType);
132
133 resourceParams.presResource = ¶ms->psRawSurface->OsResource;
134 resourceParams.dwOffset = params->psRawSurface->dwOffset;
135 resourceParams.pdwCmd = &(cmd.DW7.Value);
136 resourceParams.dwLocationInCmd = 7;
137 resourceParams.bIsWritable = false;
138
139 MHW_MI_CHK_STATUS(AddResourceToCmd(
140 m_osInterface,
141 cmdBuffer,
142 &resourceParams));
143 }
144
145 if (params->presStreamOutBuffer != nullptr)
146 {
147 cmd.DW12.MemoryObjectControlState =
148 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
149
150 cmd.DW12.StreamoutDataDestinationMemoryCompressionEnable = params->StreamOutBufMmcState != MOS_MEMCOMP_DISABLED ?
151 MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
152 cmd.DW12.StreamoutDataDestinationMemoryCompressionMode = params->StreamOutBufMmcState == MOS_MEMCOMP_HORIZONTAL ?
153 MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
154
155 resourceParams.presResource = params->presStreamOutBuffer;
156 resourceParams.dwOffset = 0;
157 resourceParams.pdwCmd = &(cmd.DW10.Value);
158 resourceParams.dwLocationInCmd = 10;
159 resourceParams.bIsWritable = true;
160
161 MHW_MI_CHK_STATUS(AddResourceToCmd(
162 m_osInterface,
163 cmdBuffer,
164 &resourceParams));
165
166 if (!m_decodeInUse)
167 {
168 cmd.DW54.MemoryObjectControlState =
169 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
170
171 resourceParams.presResource = params->presStreamOutBuffer;
172 resourceParams.dwOffset = 0;
173 resourceParams.pdwCmd = &(cmd.DW52.Value);
174 resourceParams.dwLocationInCmd = 52;
175 resourceParams.bIsWritable = true;
176
177 MHW_MI_CHK_STATUS(AddResourceToCmd(
178 m_osInterface,
179 cmdBuffer,
180 &resourceParams));
181 }
182 }
183
184 if (m_intraRowstoreCache.bEnabled)
185 {
186 cmd.DW15.IntraRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
187 cmd.DW13.IntraRowStoreScratchBufferBaseAddress = m_intraRowstoreCache.dwAddress;
188 }
189 else if (params->presMfdIntraRowStoreScratchBuffer != nullptr)
190 {
191 cmd.DW15.MemoryObjectControlState =
192 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
193
194 cmd.DW15.IntraRowStoreScratchBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
195
196 resourceParams.presResource = params->presMfdIntraRowStoreScratchBuffer;
197 resourceParams.dwOffset = 0;
198 resourceParams.pdwCmd = &(cmd.DW13.Value);
199 resourceParams.dwLocationInCmd = 13;
200 resourceParams.bIsWritable = true;
201
202 MHW_MI_CHK_STATUS(AddResourceToCmd(
203 m_osInterface,
204 cmdBuffer,
205 &resourceParams));
206 }
207
208 if (m_deblockingFilterRowstoreCache.bEnabled)
209 {
210 cmd.DW18.DeblockingFilterRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
211 cmd.DW16.DeblockingFilterRowStoreScratchBaseAddress =
212 m_deblockingFilterRowstoreCache.dwAddress;
213 }
214 else if (params->presMfdDeblockingFilterRowStoreScratchBuffer != nullptr)
215 {
216 cmd.DW18.MemoryObjectControlState =
217 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
218 cmd.DW18.DeblockingFilterRowStoreScratchMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
219
220 resourceParams.presResource = params->presMfdDeblockingFilterRowStoreScratchBuffer;
221 resourceParams.dwOffset = 0;
222 resourceParams.pdwCmd = &(cmd.DW16.Value);
223 resourceParams.dwLocationInCmd = 16;
224 resourceParams.bIsWritable = true;
225
226 MHW_MI_CHK_STATUS(AddResourceToCmd(
227 m_osInterface,
228 cmdBuffer,
229 &resourceParams));
230 }
231
232 bool firstRefPic = true;
233 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
234 {
235 if (params->presReferences[i] != nullptr)
236 {
237 MOS_SURFACE resDetails;
238 MOS_ZeroMemory(&resDetails, sizeof(resDetails));
239 resDetails.Format = Format_Invalid;
240 MHW_MI_CHK_STATUS(m_osInterface->pfnGetResourceInfo(m_osInterface, params->presReferences[i], &resDetails));
241
242 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
243 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, params->presReferences[i], &mmcMode));
244
245 if (mmcMode == MOS_MEMCOMP_HORIZONTAL)
246 {
247 cmd.DW61.Value |= (MHW_MEDIA_MEMCOMP_ENABLED << (i * 2)) | (MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL << (i * 2 + 1));
248 }
249 else if (mmcMode == MOS_MEMCOMP_VERTICAL)
250 {
251 cmd.DW61.Value |= (MHW_MEDIA_MEMCOMP_ENABLED << (i * 2)) | (MHW_MEDIA_MEMCOMP_MODE_VERTICAL << (i * 2 + 1));
252 }
253 else
254 {
255 cmd.DW61.Value |= MHW_MEDIA_MEMCOMP_DISABLED << (i * 2);
256 }
257
258 if (firstRefPic)
259 {
260 cmd.DW51.ReferencePictureTiledResourceMode = Mhw_ConvertToTRMode(resDetails.TileType);
261 firstRefPic = false;
262 }
263
264 resourceParams.presResource = params->presReferences[i];
265 resourceParams.dwOffset = resDetails.RenderOffset.YUV.Y.BaseOffset;
266 resourceParams.pdwCmd = &(cmd.Refpicbaseaddr[i].DW0_1.Value[0]);
267 resourceParams.dwLocationInCmd = (i * 2) + 19; // * 2 to account for QW rather than DW
268 resourceParams.bIsWritable = false;
269
270 resourceParams.dwSharedMocsOffset = 51 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW51
271
272 MHW_MI_CHK_STATUS(AddResourceToCmd(
273 m_osInterface,
274 cmdBuffer,
275 &resourceParams));
276 }
277 }
278
279 // There is only one control DW51 for all references
280 cmd.DW51.MemoryObjectControlState =
281 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
282
283 // Reset dwSharedMocsOffset
284 resourceParams.dwSharedMocsOffset = 0;
285
286 if (params->presMacroblockIldbStreamOutBuffer1 != nullptr)
287 {
288 cmd.DW57.MemoryObjectControlState =
289 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC].Value;
290 cmd.DW57.MacroblockIldbStreamoutBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
291 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer1;
292 resourceParams.dwOffset = 0;
293 resourceParams.pdwCmd = &(cmd.DW55.Value);
294 resourceParams.dwLocationInCmd = 55;
295 resourceParams.bIsWritable = true;
296
297 MHW_MI_CHK_STATUS(AddResourceToCmd(
298 m_osInterface,
299 cmdBuffer,
300 &resourceParams));
301 }
302
303 if (params->presMacroblockIldbStreamOutBuffer2 != nullptr)
304 {
305 cmd.DW60.MemoryObjectControlState =
306 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC].Value;
307 cmd.DW60.SecondMacroblockIldbStreamoutBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
308 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer2;
309 resourceParams.dwOffset = 0;
310 resourceParams.pdwCmd = &(cmd.DW58.Value);
311 resourceParams.dwLocationInCmd = 58;
312 resourceParams.bIsWritable = true;
313
314 MHW_MI_CHK_STATUS(AddResourceToCmd(
315 m_osInterface,
316 cmdBuffer,
317 &resourceParams));
318 }
319
320 // Add 4xDS surface for VDENC
321 if (params->bVdencEnabled && params->ps4xDsSurface != nullptr)
322 {
323 resourceParams.presResource = ¶ms->ps4xDsSurface->OsResource;
324 resourceParams.dwOffset = params->ps4xDsSurface->dwOffset;
325 resourceParams.pdwCmd = &(cmd.DW62.Value);
326 resourceParams.dwLocationInCmd = 62;
327 resourceParams.bIsWritable = true;
328
329 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
330 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, resourceParams.presResource, &mmcMode));
331
332 if (mmcMode == MOS_MEMCOMP_DISABLED)
333 {
334 params->Ps4xDsSurfMmcState = MOS_MEMCOMP_DISABLED;
335 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
336 }
337 else
338 {
339 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_ENABLED;
340 }
341 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionMode = (params->Ps4xDsSurfMmcState == MOS_MEMCOMP_HORIZONTAL) ?
342 MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
343 cmd.DW64.ScaledReferenceSurfaceIndexToMemoryObjectControlStateMocsTables =
344 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value >> 1;
345
346 cmd.DW64.ScaledReferenceSurfaceTiledResourceMode = Mhw_ConvertToTRMode(params->ps4xDsSurface->TileType);
347
348 MHW_MI_CHK_STATUS(AddResourceToCmd(
349 m_osInterface,
350 cmdBuffer,
351 &resourceParams));
352
353 MHW_MI_CHK_STATUS(m_osInterface->pfnSetMemoryCompressionMode(m_osInterface, resourceParams.presResource, params->Ps4xDsSurfMmcState));
354 }
355
356 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd)));
357
358 return eStatus;
359 }
360