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, &params->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 = &params->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 = &params->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