Debian Codegraph @

media_driver/agnostic/gen9_kbl/hw/vdbox/mhw_vdbox_mfx_g9_kbl.cpp

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