Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_mmc.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 codechal_mmc.cpp
24 //! \brief Impelements the public interface for CodecHal Media Memory Compression
25 //!
26
27 #include "codechal_hw.h"
28 #include "codechal_mmc.h"
29
30 CodecHalMmcState::CodecHalMmcState(CodechalHwInterface *hwInterface)
31 {
32 CODECHAL_HW_FUNCTION_ENTER;
33
34 CODECHAL_HW_ASSERT(hwInterface);
35 m_hwInterface = hwInterface;
36 CODECHAL_HW_ASSERT(hwInterface->GetOsInterface());
37 m_osInterface = hwInterface->GetOsInterface();
38 CODECHAL_HW_ASSERT(hwInterface->GetSkuTable());
39
40 m_hcpMmcEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrHcpDecMemoryCompression);
41 m_10bitMmcEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), Ftr10bitDecMemoryCompression);
42 m_gpuMmuPageFaultEnabled = MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrGpuMmuPageFault);
43
44 if (MEDIA_IS_SKU(hwInterface->GetSkuTable(), FtrMemoryCompression))
45 {
46 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
47 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
48
49 // read reg key of Codec MMC enabling. MMC default on.
50 userFeatureData.i32Data = true;
51 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
52
53 MOS_USER_FEATURE_VALUE_ID valueId = __MEDIA_USER_FEATURE_VALUE_CODEC_MMC_ENABLE_ID;
54 MOS_UserFeature_ReadValue_ID(
55 nullptr,
56 valueId,
57 &userFeatureData,
58 m_osInterface->pOsContext);
59 m_mmcEnabled = (userFeatureData.i32Data) ? true : false;
60
61 // report in-use
62 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
63 MOS_ZeroMemory(&userFeatureWriteData, sizeof(userFeatureWriteData));
64 userFeatureWriteData.Value.i32Data = m_mmcEnabled;
65 userFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_CODEC_MMC_IN_USE_ID;
66 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
67 }
68 }
69 bool CodecHalMmcState::IsMmcEnabled()
70 {
71 CODECHAL_HW_FUNCTION_ENTER;
72
73 return m_mmcEnabled;
74 }
75
76 void CodecHalMmcState::SetMmcDisabled()
77 {
78 CODECHAL_HW_FUNCTION_ENTER;
79
80 m_mmcEnabled = false;
81 }
82 MOS_STATUS CodecHalMmcState::GetSurfaceMmcState(PMOS_SURFACE surface)
83 {
84 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
85
86 CODECHAL_HW_FUNCTION_ENTER;
87
88 if (m_mmcEnabled)
89 {
90 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
91 m_osInterface,
92 &surface->OsResource,
93 (PMOS_MEMCOMP_STATE)&surface->CompressionMode));
94 }
95
96 return eStatus;
97 }
98
99 MOS_STATUS CodecHalMmcState::GetSurfaceMmcState(PMOS_SURFACE surface,MOS_MEMCOMP_STATE *mmcState)
100 {
101 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
102
103 CODECHAL_HW_FUNCTION_ENTER;
104
105 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, surface);
106 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, mmcState);
107 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, m_osInterface);
108
109 if (m_mmcEnabled)
110 {
111 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
112 m_osInterface,
113 &surface->OsResource,
114 (PMOS_MEMCOMP_STATE)&surface->CompressionMode));
115 *mmcState = (MOS_MEMCOMP_STATE)surface->CompressionMode;
116 }
117 else
118 {
119 *mmcState = MOS_MEMCOMP_DISABLED;
120 }
121
122 return eStatus;
123 }
124
125 MOS_STATUS CodecHalMmcState::GetSurfaceMmcFormat(
126 PMOS_SURFACE surface,
127 uint32_t *mmcFormat)
128 {
129 MOS_STATUS status = MOS_STATUS_SUCCESS;
130
131 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, surface);
132 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, mmcFormat);
133 MOS_CHK_NULL_RETURN(MOS_COMPONENT_MMC, MOS_MMC_SUBCOMP_SELF, m_osInterface);
134
135 if (m_mmcEnabled)
136 {
137 status = m_osInterface->pfnGetMemoryCompressionFormat(m_osInterface, &surface->OsResource, mmcFormat);
138 }
139 else
140 {
141 *mmcFormat = 0;
142 }
143
144 return status;
145 }
146
147
148 MOS_STATUS CodecHalMmcState::
149 DisableSurfaceMmcState(PMOS_SURFACE surface)
150 {
151 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
152
153 CODECHAL_HW_FUNCTION_ENTER;
154
155 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
156 m_osInterface,
157 &surface->OsResource,
158 MOS_MEMCOMP_DISABLED));
159
160 return eStatus;
161 }
162
163 MOS_STATUS CodecHalMmcState::SetSurfaceMmcMode(
164 PMOS_SURFACE dstSurface,
165 PMOS_SURFACE srcSurface)
166 {
167 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
168
169 CODECHAL_HW_FUNCTION_ENTER;
170
171 if (m_mmcEnabled)
172 {
173 if (srcSurface->CompressionMode == MOS_MMC_DISABLED)
174 {
175 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
176 m_osInterface,
177 &dstSurface->OsResource,
178 MOS_MEMCOMP_DISABLED));
179 dstSurface->CompressionMode = MOS_MMC_DISABLED;
180 }
181 else
182 {
183 if (dstSurface->bCompressible)
184 {
185 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
186 m_osInterface,
187 &dstSurface->OsResource,
188 (MOS_MEMCOMP_STATE)srcSurface->CompressionMode));
189 dstSurface->CompressionMode = srcSurface->CompressionMode;
190 }
191 else
192 {
193 m_osInterface->pfnDecompResource(m_osInterface, &srcSurface->OsResource);
194 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnSetMemoryCompressionMode(
195 m_osInterface,
196 &dstSurface->OsResource,
197 MOS_MEMCOMP_DISABLED));
198 dstSurface->CompressionMode = MOS_MMC_DISABLED;
199 }
200 }
201 }
202
203 return eStatus;
204 }
205
206 MOS_STATUS CodecHalMmcState::SetSurfaceParams(
207 PCODECHAL_SURFACE_CODEC_PARAMS surfaceParams)
208 {
209 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
210
211 CODECHAL_HW_FUNCTION_ENTER;
212
213 if (m_mmcEnabled)
214 {
215 CODECHAL_HW_CHK_NULL_RETURN(surfaceParams->psSurface);
216 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetMemoryCompressionMode(
217 m_osInterface,
218 &surfaceParams->psSurface->OsResource,
219 (PMOS_MEMCOMP_STATE) &surfaceParams->psSurface->CompressionMode));
220
221 // R8_UNORM is required by MMCD. For 4x downscaling, the input surface could be MMCD-compressed.
222 if (surfaceParams->psSurface->CompressionMode != MOS_MMC_DISABLED)
223 {
224 surfaceParams->bUse32UnormSurfaceFormat = false;
225 surfaceParams->bUse16UnormSurfaceFormat = false;
226 }
227 }
228
229 return eStatus;
230 }
231
232 #if (_DEBUG || _RELEASE_INTERNAL)
233 MOS_STATUS CodecHalMmcState::UpdateUserFeatureKey(PMOS_SURFACE surface)
234 {
235 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
236
237 CODECHAL_HW_FUNCTION_ENTER;
238
239 CODECHAL_HW_CHK_NULL_RETURN(surface);
240
241 if (!m_userFeatureUpdated)
242 {
243 MOS_USER_FEATURE_VALUE_WRITE_DATA userFeatureWriteData;
244 userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
245 userFeatureWriteData.Value.i32Data = surface->bCompressible;
246 userFeatureWriteData.ValueID = (MOS_USER_FEATURE_VALUE_ID)m_compressibleId;
247 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
248
249 userFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
250 userFeatureWriteData.Value.i32Data = surface->MmcState;
251 userFeatureWriteData.ValueID = (MOS_USER_FEATURE_VALUE_ID)m_compressModeId;
252 MOS_UserFeature_WriteValues_ID(nullptr, &userFeatureWriteData, 1, m_osInterface->pOsContext);
253
254 m_userFeatureUpdated = true;
255 }
256 return eStatus;
257 }
258 #endif