Debian Codegraph @

media_driver/agnostic/gen9_bxt/hw/vdbox/mhw_vdbox_mfx_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_mfx_g9_bxt.cpp
24 //! \brief Defines functions for constructing Vdbox MFX commands on G9 BXT platform
25 //!
26
27 #include "mos_os_cp_interface_specific.h"
28 #include "mhw_vdbox_mfx_g9_bxt.h"
29
30 MOS_STATUS MhwVdboxMfxInterfaceG9Bxt::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_bxt::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 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 resourceParams.presResource = &(params->psPostDeblockSurface->OsResource);
96 resourceParams.dwOffset = params->psPostDeblockSurface->dwOffset;
97 resourceParams.pdwCmd = &(cmd.DW4.Value);
98 resourceParams.dwLocationInCmd = 4;
99 resourceParams.bIsWritable = true;
100
101 MHW_MI_CHK_STATUS(AddResourceToCmd(
102 m_osInterface,
103 cmdBuffer,
104 &resourceParams));
105
106 MHW_MI_CHK_STATUS(m_osInterface->pfnSetMemoryCompressionMode(m_osInterface, resourceParams.presResource, params->PostDeblockSurfMmcState));
107 }
108
109 if (params->psRawSurface != nullptr)
110 {
111 if (!m_decodeInUse)
112 {
113 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
114 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, &params->psRawSurface->OsResource, &mmcMode));
115
116 cmd.DW9.MemoryObjectControlState =
117 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
118 cmd.DW9.OriginalUncompressedPictureMemoryCompressionEnable =
119 mmcMode != MOS_MEMCOMP_DISABLED ? MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
120 cmd.DW9.OriginalUncompressedPictureMemoryCompressionMode =
121 mmcMode == MOS_MEMCOMP_HORIZONTAL ? MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
122 }
123 else
124 {
125 cmd.DW9.MemoryObjectControlState =
126 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE].Value;
127 }
128
129 resourceParams.presResource = &params->psRawSurface->OsResource;
130 resourceParams.dwOffset = params->psRawSurface->dwOffset;
131 resourceParams.pdwCmd = &(cmd.DW7.Value);
132 resourceParams.dwLocationInCmd = 7;
133 resourceParams.bIsWritable = false;
134
135 MHW_MI_CHK_STATUS(AddResourceToCmd(
136 m_osInterface,
137 cmdBuffer,
138 &resourceParams));
139 }
140
141 if (params->presStreamOutBuffer != nullptr)
142 {
143 cmd.DW12.MemoryObjectControlState =
144 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
145
146 cmd.DW12.StreamoutDataDestinationMemoryCompressionEnable = params->StreamOutBufMmcState != MOS_MEMCOMP_DISABLED ?
147 MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
148 cmd.DW12.StreamoutDataDestinationMemoryCompressionMode = params->StreamOutBufMmcState == MOS_MEMCOMP_HORIZONTAL ?
149 MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
150
151 resourceParams.presResource = params->presStreamOutBuffer;
152 resourceParams.dwOffset = 0;
153 resourceParams.pdwCmd = &(cmd.DW10.Value);
154 resourceParams.dwLocationInCmd = 10;
155 resourceParams.bIsWritable = true;
156
157 MHW_MI_CHK_STATUS(AddResourceToCmd(
158 m_osInterface,
159 cmdBuffer,
160 &resourceParams));
161
162 if (!m_decodeInUse)
163 {
164 cmd.DW54.MemoryObjectControlState =
165 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
166
167 resourceParams.presResource = params->presStreamOutBuffer;
168 resourceParams.dwOffset = 0;
169 resourceParams.pdwCmd = &(cmd.DW52.Value);
170 resourceParams.dwLocationInCmd = 52;
171 resourceParams.bIsWritable = true;
172
173 MHW_MI_CHK_STATUS(AddResourceToCmd(
174 m_osInterface,
175 cmdBuffer,
176 &resourceParams));
177 }
178 }
179
180 if (m_intraRowstoreCache.bEnabled)
181 {
182 cmd.DW15.IntraRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
183 cmd.DW13.IntraRowStoreScratchBufferBaseAddress = m_intraRowstoreCache.dwAddress;
184 }
185 else if (params->presMfdIntraRowStoreScratchBuffer != nullptr)
186 {
187 cmd.DW15.MemoryObjectControlState =
188 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
189
190 cmd.DW15.IntraRowStoreScratchBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
191
192 resourceParams.presResource = params->presMfdIntraRowStoreScratchBuffer;
193 resourceParams.dwOffset = 0;
194 resourceParams.pdwCmd = &(cmd.DW13.Value);
195 resourceParams.dwLocationInCmd = 13;
196 resourceParams.bIsWritable = true;
197
198 MHW_MI_CHK_STATUS(AddResourceToCmd(
199 m_osInterface,
200 cmdBuffer,
201 &resourceParams));
202 }
203
204 if (m_deblockingFilterRowstoreCache.bEnabled)
205 {
206 cmd.DW18.DeblockingFilterRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
207 cmd.DW16.DeblockingFilterRowStoreScratchBaseAddress =
208 m_deblockingFilterRowstoreCache.dwAddress;
209 }
210 else if (params->presMfdDeblockingFilterRowStoreScratchBuffer != nullptr)
211 {
212 cmd.DW18.MemoryObjectControlState =
213 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
214 cmd.DW18.DeblockingFilterRowStoreScratchMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
215
216 resourceParams.presResource = params->presMfdDeblockingFilterRowStoreScratchBuffer;
217 resourceParams.dwOffset = 0;
218 resourceParams.pdwCmd = &(cmd.DW16.Value);
219 resourceParams.dwLocationInCmd = 16;
220 resourceParams.bIsWritable = true;
221
222 MHW_MI_CHK_STATUS(AddResourceToCmd(
223 m_osInterface,
224 cmdBuffer,
225 &resourceParams));
226 }
227
228 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
229 {
230 if (params->presReferences[i] != nullptr)
231 {
232 MOS_SURFACE details;
233 MOS_ZeroMemory(&details, sizeof(details));
234 details.Format = Format_Invalid;
235 MHW_MI_CHK_STATUS(m_osInterface->pfnGetResourceInfo(m_osInterface, params->presReferences[i], &details));
236
237 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
238 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, params->presReferences[i], &mmcMode));
239
240 if (mmcMode == MOS_MEMCOMP_HORIZONTAL)
241 {
242 cmd.DW61.Value |= (MHW_MEDIA_MEMCOMP_ENABLED << (i * 2)) | (MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL << (i * 2 + 1));
243 }
244 else if (mmcMode == MOS_MEMCOMP_VERTICAL)
245 {
246 cmd.DW61.Value |= (MHW_MEDIA_MEMCOMP_ENABLED << (i * 2)) | (MHW_MEDIA_MEMCOMP_MODE_VERTICAL << (i * 2 + 1));
247 }
248 else
249 {
250 cmd.DW61.Value |= MHW_MEDIA_MEMCOMP_DISABLED << (i * 2);
251 }
252
253 resourceParams.presResource = params->presReferences[i];
254 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
255 resourceParams.pdwCmd = &(cmd.Refpicbaseaddr[i].DW0_1.Value[0]);
256 resourceParams.dwLocationInCmd = (i * 2) + 19; // * 2 to account for QW rather than DW
257 resourceParams.bIsWritable = false;
258
259 resourceParams.dwSharedMocsOffset = 51 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW51
260
261 MHW_MI_CHK_STATUS(AddResourceToCmd(
262 m_osInterface,
263 cmdBuffer,
264 &resourceParams));
265 }
266 }
267
268 // There is only one control DW51 for all references
269 cmd.DW51.MemoryObjectControlState =
270 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
271
272 // Reset dwSharedMocsOffset
273 resourceParams.dwSharedMocsOffset = 0;
274
275 if (params->presMacroblockIldbStreamOutBuffer1 != nullptr)
276 {
277 cmd.DW57.MemoryObjectControlState =
278 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC].Value;
279 cmd.DW57.MacroblockIldbStreamoutBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
280 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer1;
281 resourceParams.dwOffset = 0;
282 resourceParams.pdwCmd = &(cmd.DW55.Value);
283 resourceParams.dwLocationInCmd = 55;
284 resourceParams.bIsWritable = true;
285
286 MHW_MI_CHK_STATUS(AddResourceToCmd(
287 m_osInterface,
288 cmdBuffer,
289 &resourceParams));
290 }
291
292 if (params->presMacroblockIldbStreamOutBuffer2 != nullptr)
293 {
294 cmd.DW60.MemoryObjectControlState =
295 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC].Value;
296 cmd.DW60.SecondMacroblockIldbStreamoutBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
297 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer2;
298 resourceParams.dwOffset = 0;
299 resourceParams.pdwCmd = &(cmd.DW58.Value);
300 resourceParams.dwLocationInCmd = 58;
301 resourceParams.bIsWritable = true;
302
303 MHW_MI_CHK_STATUS(AddResourceToCmd(
304 m_osInterface,
305 cmdBuffer,
306 &resourceParams));
307 }
308
309 // Add 4xDS surface for VDENC
310 if (params->bVdencEnabled && params->ps4xDsSurface != nullptr)
311 {
312 resourceParams.presResource = &params->ps4xDsSurface->OsResource;
313 resourceParams.dwOffset = params->ps4xDsSurface->dwOffset;
314 resourceParams.pdwCmd = &(cmd.DW62.Value);
315 resourceParams.dwLocationInCmd = 62;
316 resourceParams.bIsWritable = true;
317
318 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
319 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, resourceParams.presResource, &mmcMode));
320
321 if (mmcMode == MOS_MEMCOMP_DISABLED)
322 {
323 params->Ps4xDsSurfMmcState = MOS_MEMCOMP_DISABLED;
324 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
325 }
326 else
327 {
328 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_ENABLED;
329 }
330 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionMode = (params->Ps4xDsSurfMmcState == MOS_MEMCOMP_HORIZONTAL) ?
331 MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
332
333 cmd.DW64.ScaledReferenceSurfaceIndexToMemoryObjectControlStateMocsTables =
334 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value >> 1;
335
336 MHW_MI_CHK_STATUS(AddResourceToCmd(
337 m_osInterface,
338 cmdBuffer,
339 &resourceParams));
340
341 MHW_MI_CHK_STATUS(m_osInterface->pfnSetMemoryCompressionMode(m_osInterface, resourceParams.presResource, params->Ps4xDsSurfMmcState));
342 }
343
344 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
345
346 return eStatus;
347 }