Debian Codegraph @

media_driver/agnostic/gen12/vp/hal/vphal_render_vebox_g12_base.cpp

raw
1 /*
2 * Copyright (c) 2011-2022, 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 vphal_render_vebox_g12_base.cpp
24 //! \brief Interface and structure specific for GEN12 Vebox
25 //! \details Interface and structure specific for GEN12 Vebox
26 //!
27 #include "vphal.h"
28 #include "vphal_debug.h"
29 #include "vphal_render_vebox_g12_base.h"
30 #include "vphal_render_sfc_g12_base.h"
31 #include "vphal_render_vebox_util_base.h"
32 #include "vpkrnheader.h"
33 #include "mhw_vebox_g12_X.h"
34 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
35 #if (IGFX_GEN12_TGLLP_SUPPORTED)
36 #include "igvpkrn_isa_g12_tgllp.h"
37 #endif
38 #endif
39 #include "vphal_render_hdr_3dlut_g12.h"
40 #include "vp_hal_ddi_utils.h"
41
42 const char g_KernelDNDI_Str_g12[KERNEL_VEBOX_BASE_MAX][MAX_PATH] =
43 {
44 DBG_TEXT("Reserved"),
45 DBG_TEXT("UpdateDNState"),
46 };
47
48 // Kernel Params ---------------------------------------------------------------
49 const RENDERHAL_KERNEL_PARAM g_Vebox_KernelParam_g12[KERNEL_VEBOX_BASE_MAX] =
50 {
51 ///* GRF_Count
52 // | BT_Count
53 // | | Sampler_Count
54 // | | | Thread_Count
55 // | | | | GRF_Start_Register
56 // | | | | | CURBE_Length
57 // | | | | | | block_width
58 // | | | | | | | block_height
59 // | | | | | | | | blocks_x
60 // | | | | | | | | | blocks_y
61 // | | | | | | | | | |*/
62 { 0, 0 , 0, VPHAL_USE_MEDIA_THREADS_MAX, 0, 0, 0, 0, 0, 0 }, // RESERVED
63 { 4, 34, 0, VPHAL_USE_MEDIA_THREADS_MAX, 0, 2, 64, 8, 1, 1 }, // UPDATEDNSTATE
64 };
65
66 const uint32_t dwDenoiseASDThreshold[NOISEFACTOR_MAX + 1] = {
67 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542,
68 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574,
69 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606,
70 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638,
71 640 };
72
73 const uint32_t dwDenoiseHistoryDelta[NOISEFACTOR_MAX + 1] = {
74 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
75 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
76 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
77 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
78 8 };
79
80 const uint32_t dwDenoiseMaximumHistory[NOISEFACTOR_MAX + 1] = {
81 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
82 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
83 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
84 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
85 208 };
86
87 const uint32_t dwDenoiseSTADThreshold[NOISEFACTOR_MAX + 1] = {
88 2048, 2052, 2056, 2060, 2064, 2068, 2072, 2076, 2080, 2084, 2088, 2092, 2096, 2100, 2104, 2108,
89 2112, 2116, 2120, 2124, 2128, 2132, 2136, 2140, 2144, 2148, 2152, 2156, 2160, 2164, 2168, 2172,
90 2176, 2180, 2184, 2188, 2192, 2196, 2200, 2204, 2208, 2212, 2216, 2220, 2224, 2228, 2232, 2236,
91 2240, 2244, 2248, 2252, 2256, 2260, 2264, 2268, 2272, 2276, 2280, 2284, 2288, 2292, 2296, 2300,
92 2304 };
93
94 const uint32_t dwDenoiseSCMThreshold[NOISEFACTOR_MAX + 1] = {
95 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542,
96 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574,
97 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606,
98 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638,
99 640 };
100
101 const uint32_t dwDenoiseMPThreshold[NOISEFACTOR_MAX + 1] = {
102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
104 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
105 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
106 2 };
107
108 const uint32_t dwLTDThreshold[NOISEFACTOR_MAX + 1] = {
109 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
110 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
111 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
113 128 };
114
115 const uint32_t dwTDThreshold[NOISEFACTOR_MAX + 1] = {
116 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
117 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
118 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
119 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
120 192 };
121
122 const uint32_t dwGoodNeighborThreshold[NOISEFACTOR_MAX + 1] = {
123 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
124 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
125 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
126 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
127 0 };
128
129 const uint32_t dwPixRangeThreshold0[NOISEFACTOR_MAX + 1] = {
130 32, 37, 42, 47, 52, 57, 62, 67, 72, 77, 82, 87, 92, 97, 102, 107,
131 112, 117, 122, 127, 132, 137, 142, 147, 152, 157, 162, 167, 172, 177, 182, 187,
132 192, 198, 204, 210, 216, 222, 228, 234, 240, 246, 252, 258, 264, 270, 276, 282,
133 288, 294, 300, 306, 312, 318, 324, 330, 336, 342, 348, 354, 360, 366, 372, 378,
134 384 };
135
136 const uint32_t dwPixRangeThreshold1[NOISEFACTOR_MAX + 1] = {
137 64, 70, 76, 82, 88, 94, 100, 106, 112, 118, 124, 130, 136, 142, 148, 154,
138 160, 166, 172, 178, 184, 190, 196, 202, 208, 214, 220, 226, 232, 238, 244, 250,
139 256, 266, 276, 286, 296, 306, 316, 326, 336, 346, 356, 366, 376, 386, 396, 406,
140 416, 426, 436, 446, 456, 466, 476, 486, 496, 506, 516, 526, 536, 546, 556, 566,
141 576 };
142
143 const uint32_t dwPixRangeThreshold2[NOISEFACTOR_MAX + 1] = {
144 128, 140, 152, 164, 176, 188, 200, 212, 224, 236, 248, 260, 272, 284, 296, 308,
145 320, 332, 344, 356, 368, 380, 392, 404, 416, 428, 440, 452, 464, 476, 488, 500,
146 512, 524, 536, 548, 560, 572, 584, 596, 608, 620, 632, 644, 656, 668, 680, 692,
147 704, 716, 728, 740, 752, 764, 776, 788, 800, 812, 824, 836, 848, 860, 872, 884,
148 896 };
149
150 const uint32_t dwPixRangeThreshold3[NOISEFACTOR_MAX + 1] = {
151 128, 144, 160, 176, 192, 208, 224, 240, 256, 272, 288, 304, 320, 336, 352, 368,
152 384, 400, 416, 432, 448, 464, 480, 496, 512, 528, 544, 560, 576, 592, 608, 624,
153 640, 660, 680, 700, 720, 740, 760, 780, 800, 820, 840, 860, 880, 900, 920, 940,
154 960, 980, 1000, 1020, 1040, 1060, 1080, 1100, 1120, 1140, 1160, 1180, 1200, 1220, 1240, 1260,
155 1280 };
156
157 const uint32_t dwPixRangeThreshold4[NOISEFACTOR_MAX + 1] = {
158 128, 152, 176, 200, 224, 248, 272, 296, 320, 344, 368, 392, 416, 440, 464, 488,
159 512, 536, 560, 584, 608, 632, 656, 680, 704, 728, 752, 776, 800, 824, 848, 872,
160 896, 928, 960, 992, 1024, 1056, 1088, 1120, 1152, 1184, 1216, 1248, 1280, 1312, 1344, 1376,
161 1408, 1440, 1472, 1504, 1536, 1568, 1600, 1632, 1664, 1696, 1728, 1760, 1792, 1824, 1856, 1888,
162 1920 };
163
164 const uint32_t dwPixRangeThreshold5[NOISEFACTOR_MAX + 1] = {
165 128, 164, 200, 236, 272, 308, 344, 380, 416, 452, 488, 524, 560, 596, 632, 668,
166 704, 740, 776, 812, 848, 884, 920, 956, 992, 1028, 1064, 1100, 1136, 1172, 1208, 1244,
167 1280, 1320, 1360, 1400, 1440, 1480, 1520, 1560, 1600, 1640, 1680, 1720, 1760, 1800, 1840, 1880,
168 1920, 1960, 2000, 2040, 2080, 2120, 2160, 2200, 2240, 2280, 2320, 2360, 2400, 2440, 2480, 2520,
169 2560 };
170
171 const uint32_t dwPixRangeWeight0[NOISEFACTOR_MAX + 1] = {
172 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
173 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
174 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
175 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
176 16 };
177
178 const uint32_t dwPixRangeWeight1[NOISEFACTOR_MAX + 1] = {
179 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 11,
180 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13,
181 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
182 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
183 15 };
184
185 const uint32_t dwPixRangeWeight2[NOISEFACTOR_MAX + 1] = {
186 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5,
187 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9,
188 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11,
189 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
190 13 };
191
192 const uint32_t dwPixRangeWeight3[NOISEFACTOR_MAX + 1] = {
193 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2,
194 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
195 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7,
196 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,
197 10 };
198
199 const uint32_t dwPixRangeWeight4[NOISEFACTOR_MAX + 1] = {
200 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
201 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
202 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4,
203 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
204 7 };
205
206 const uint32_t dwPixRangeWeight5[NOISEFACTOR_MAX + 1] = {
207 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
208 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
209 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
210 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
211 4 };
212
213 const uint32_t dwLTDThresholdUV[NOISEFACTOR_MAX + 1] = {
214 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
215 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
216 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
217 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
218 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128 };
219
220 const uint32_t dwTDThresholdUV[NOISEFACTOR_MAX + 1] = {
221 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172,
222 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
223 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
224 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
225 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224 };
226
227 const uint32_t dwSTADThresholdUV[NOISEFACTOR_MAX + 1] = {
228 2048, 2052, 2056, 2060, 2064, 2068, 2072, 2076, 2080, 2084, 2088, 2092, 2096,
229 2100, 2104, 2108, 2112, 2116, 2120, 2124, 2128, 2132, 2136, 2140, 2144, 2148,
230 2152, 2156, 2160, 2164, 2168, 2172, 2176, 2180, 2184, 2188, 2192, 2196, 2200,
231 2204, 2208, 2212, 2216, 2220, 2224, 2228, 2232, 2236, 2240, 2244, 2248, 2252,
232 2256, 2260, 2264, 2268, 2272, 2276, 2280, 2284, 2288, 2292, 2296, 2300, 2304};
233
234 //!
235 //! \brief Vebox format support check
236 //! \details Checks to see if Vebox operation is supported with source surface format
237 //! \param [in] pSrcSurface
238 //! Pointer to input surface of Vebox
239 //! \return bool
240 //! return true if input surface format is supported, otherwise false
241 //!
242 bool VPHAL_VEBOX_STATE_G12_BASE::IsFormatSupported(
243 PVPHAL_SURFACE pSrcSurface)
244 {
245 bool bRet = false;
246 VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrcSurface);
247
248 // Check if Sample Format is supported
249 // Vebox only support P016 format, P010 format can be supported by faking it as P016
250 if (pSrcSurface->Format != Format_NV12 &&
251 pSrcSurface->Format != Format_AYUV &&
252 pSrcSurface->Format != Format_P010 &&
253 pSrcSurface->Format != Format_P016 &&
254 pSrcSurface->Format != Format_P210 &&
255 pSrcSurface->Format != Format_P216 &&
256 pSrcSurface->Format != Format_Y8 &&
257 pSrcSurface->Format != Format_Y16U &&
258 pSrcSurface->Format != Format_Y16S &&
259 !IS_PA_FORMAT(pSrcSurface->Format))
260 {
261 VPHAL_RENDER_NORMALMESSAGE("Unsupported Source Format '0x%08x' for VEBOX.", pSrcSurface->Format);
262 goto finish;
263 }
264
265 bRet = true;
266
267 finish:
268 return bRet;
269 }
270
271 //!
272 //! \brief Vebox format support check
273 //! \details Checks to see if RT format is supported when Vebox output pipe is selected
274 //! \param [in] pSrcSurface
275 //! Pointer to Render source surface of VPP BLT
276 //! \param [in] pRTSurface
277 //! Pointer to Render target surface of VPP BLT
278 //! \return bool
279 //! return true if render target surface format is supported, otherwise false
280 //!
281 bool VPHAL_VEBOX_STATE_G12_BASE::IsRTFormatSupported(
282 PVPHAL_SURFACE pSrcSurface,
283 PVPHAL_SURFACE pRTSurface)
284 {
285 bool bRet = false;
286
287 if ((nullptr == pSrcSurface) || (nullptr == pRTSurface))
288 {
289 VPHAL_RENDER_ASSERTMESSAGE(" invalid surface");
290 return false;
291 }
292
293 // Check if RT Format is supported by Vebox
294 if (IS_PA_FORMAT(pRTSurface->Format) ||
295 pRTSurface->Format == Format_NV12 ||
296 pRTSurface->Format == Format_AYUV ||
297 pRTSurface->Format == Format_P010 ||
298 pRTSurface->Format == Format_P016 ||
299 pRTSurface->Format == Format_P210 ||
300 pRTSurface->Format == Format_P216 ||
301 pRTSurface->Format == Format_Y8 ||
302 pRTSurface->Format == Format_Y16U ||
303 pRTSurface->Format == Format_Y16S)
304 {
305 // Supported Vebox Render Target format. Vebox Pipe Output can be selected.
306 bRet = true;
307 }
308
309 if ((pSrcSurface->ColorSpace == CSpace_BT2020) &&
310 ((pSrcSurface->Format == Format_P010) ||
311 (pSrcSurface->Format == Format_P016)) &&
312 // YuvChannelSwap is no longer supported from GEN10+, so we only accept 32-bits no swapped format.
313 (IS_RGB32_FORMAT(pRTSurface->Format) && IS_RGB_NO_SWAP(pRTSurface->Format)))
314 {
315 bRet = true;
316 }
317
318 return bRet;
319 }
320
321 //!
322 //! \brief Vebox format support check for DN
323 //! \details Check if the input surface format is supported for DN
324 //! \param [in] pSrcSurface
325 //! Pointer to input surface of Vebox
326 //! \return bool
327 //! return true if input surface format is supported, otherwise false
328 //!
329 bool VPHAL_VEBOX_STATE_G12_BASE::IsDnFormatSupported(
330 PVPHAL_SURFACE pSrcSurface)
331 {
332 if (nullptr == pSrcSurface)
333 {
334 VPHAL_RENDER_ASSERTMESSAGE(" invalid surface");
335 return false;
336 }
337 if ((pSrcSurface->Format != Format_YUYV) &&
338 (pSrcSurface->Format != Format_VYUY) &&
339 (pSrcSurface->Format != Format_YVYU) &&
340 (pSrcSurface->Format != Format_UYVY) &&
341 (pSrcSurface->Format != Format_YUY2) &&
342 (pSrcSurface->Format != Format_Y8) &&
343 (pSrcSurface->Format != Format_NV12) &&
344 (pSrcSurface->Format != Format_AYUV) &&
345 (pSrcSurface->Format != Format_Y216) &&
346 (pSrcSurface->Format != Format_Y210) &&
347 (pSrcSurface->Format != Format_Y416) &&
348 (pSrcSurface->Format != Format_Y410) &&
349 (pSrcSurface->Format != Format_P216) &&
350 (pSrcSurface->Format != Format_P010) &&
351 (pSrcSurface->Format != Format_P016) &&
352 (pSrcSurface->Format != Format_A8B8G8R8) &&
353 (pSrcSurface->Format != Format_A16B16G16R16))
354 {
355 VPHAL_RENDER_NORMALMESSAGE("Unsupported Format '0x%08x' for VEBOX DN.", pSrcSurface->Format);
356 return false;
357 }
358
359 return true;
360 }
361
362 //!
363 //! \brief Check if surface format is supported by DI
364 //! \details Check if surface format is supported by DI
365 //! \param [in] pSrc
366 //! Pointer to input surface of Vebox
367 //! \return bool
368 //! Return true if surface format is supported, otherwise return false
369 //!
370 bool VPHAL_VEBOX_STATE_G12_BASE::IsDiFormatSupported(
371 PVPHAL_SURFACE pSrc)
372 {
373 bool bRet = false;
374
375 VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrc);
376
377 if (pSrc->Format != Format_AYUV &&
378 pSrc->Format != Format_Y416 &&
379 pSrc->Format != Format_Y410 &&
380 pSrc->Format != Format_A8B8G8R8 &&
381 pSrc->Format != Format_A8R8G8B8 &&
382 pSrc->Format != Format_B10G10R10A2 &&
383 pSrc->Format != Format_R10G10B10A2 &&
384 pSrc->Format != Format_A16B16G16R16 &&
385 pSrc->Format != Format_A16R16G16B16)
386 {
387 bRet = true;
388 }
389 else
390 {
391 bRet = false;
392 }
393
394 finish:
395 return bRet;
396 }
397
398 //!
399 //! \brief IsFormatMMCSupported
400 //! \details Check if the format of vebox output surface is supported by MMC
401 //! \param [in] format
402 //! \return bool true if suported, otherwise not supported
403 //!
404 bool VPHAL_VEBOX_STATE_G12_BASE::IsFormatMMCSupported(
405 MOS_FORMAT format)
406 {
407 bool bRet = false;
408
409 if ((format != Format_YUY2) &&
410 (format != Format_Y210) &&
411 (format != Format_Y410) &&
412 (format != Format_Y216) &&
413 (format != Format_Y416) &&
414 (format != Format_P010) &&
415 (format != Format_P016) &&
416 (format != Format_AYUV) &&
417 (format != Format_NV21) &&
418 (format != Format_NV12) &&
419 (format != Format_UYVY) &&
420 (format != Format_YUYV) &&
421 (format != Format_R10G10B10A2) &&
422 (format != Format_B10G10R10A2) &&
423 (format != Format_A8B8G8R8) &&
424 (format != Format_X8B8G8R8) &&
425 (format != Format_A8R8G8B8) &&
426 (format != Format_X8R8G8B8) &&
427 (format != Format_A16B16G16R16F) &&
428 (format != Format_A16R16G16B16F))
429 {
430 VPHAL_RENDER_NORMALMESSAGE("Unsupported Format '0x%08x' for VEBOX MMC ouput.", format);
431 goto finish;
432 }
433
434 bRet = true;
435
436 finish:
437 return bRet;
438 }
439
440 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::GetFFDISurfParams(
441 VPHAL_CSPACE &ColorSpace,
442 VPHAL_SAMPLE_TYPE &SampleType)
443 {
444 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
445
446 VPHAL_RENDER_CHK_NULL_RETURN(pRenderData);
447 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData))
448 {
449 ColorSpace = m_sfcPipeState->GetInputColorSpace();
450 }
451 else
452 {
453 ColorSpace = m_currentSurface->ColorSpace;
454 }
455
456 // When IECP is enabled and Bob or interlaced scaling is selected for interlaced input,
457 // output surface's SampleType should be same to input's. Bob is being
458 // done in Composition part
459 if ((pRenderData->bIECP &&
460 (m_currentSurface->pDeinterlaceParams &&
461 m_currentSurface->pDeinterlaceParams->DIMode == DI_MODE_BOB)) ||
462 m_currentSurface->bInterlacedScaling)
463 {
464 SampleType = m_currentSurface->SampleType;
465 }
466 else
467 {
468 SampleType = SAMPLE_PROGRESSIVE;
469 }
470
471 return MOS_STATUS_SUCCESS;
472 }
473
474 //!
475 //! \brief Get Output surface params needed when allocate surfaces
476 //! \details Get Output surface params needed when allocate surfaces
477 //! \param [out] Format
478 //! Format of output surface
479 //! \param [out] TileType
480 //! Tile type of output surface
481 //! \return MOS_STATUS
482 //! Return MOS_STATUS_SUCCESS if success, otherwise failed
483 //!
484 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::GetOutputSurfParams(
485 MOS_FORMAT &Format,
486 MOS_TILE_TYPE &TileType)
487 {
488 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
489 VPHAL_RENDER_CHK_NULL_RETURN(pRenderData);
490
491 if (pRenderData->bDeinterlace)
492 {
493 //set vebox output as NV12 if render target is non_YUY2 for saving bandwidth.
494 if (pRenderData->pRenderTarget->Format == Format_YUY2)
495 {
496 Format = Format_YUY2;
497 }
498 else
499 {
500 Format = Format_NV12;
501 }
502 TileType = MOS_TILE_Y;
503 }
504 else
505 {
506 Format = IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData) ?
507 m_sfcPipeState->GetInputFormat() :
508 m_currentSurface->Format;
509 TileType = m_currentSurface->TileType;
510 }
511
512 return MOS_STATUS_SUCCESS;
513 }
514
515 //!
516 //! \brief Check for DN only case
517 //! \details Check for DN only case
518 //! \return bool
519 //! Return true if DN only case, otherwise not
520 //!
521 bool VPHAL_VEBOX_STATE_G12_BASE::IsDNOnly()
522 {
523 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
524 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
525
526 return pRenderData->bDenoise &&
527 (!pRenderData->bDeinterlace) &&
528 (!IsQueryVarianceEnabled()) &&
529 (!IsIECPEnabled());
530 finish:
531 return false;
532 }
533
534 bool VPHAL_VEBOX_STATE_G12_BASE::IsFFDISurfNeeded()
535 {
536 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
537 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
538
539
540 if (pRenderData->bDeinterlace ||
541 IsQueryVarianceEnabled() ||
542 pRenderData->bIECP ||
543 (pRenderData->bDenoise && IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData))) // DN + SFC needs IECP implicitly and outputs to DI surface
544 {
545 return true;
546 }
547 else
548 {
549 return false;
550 }
551 finish:
552 return false;
553 }
554
555 bool VPHAL_VEBOX_STATE_G12_BASE::IsFFDNSurfNeeded()
556 {
557 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
558 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
559 return pRenderData->bDenoise ? true : false;
560 finish:
561 return false;
562 }
563
564 bool VPHAL_VEBOX_STATE_G12_BASE::IsSTMMSurfNeeded()
565 {
566 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
567 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
568 return (pRenderData->bDenoise || pRenderData->bDeinterlace);
569 finish:
570 return false;
571 }
572
573 //!
574 //! \brief Vebox allocate resources
575 //! \details Allocate resources that will be used in Vebox
576 //! \return MOS_STATUS
577 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
578 //!
579 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::AllocateResources()
580 {
581 MOS_STATUS eStatus;
582 PMOS_INTERFACE pOsInterface;
583 PRENDERHAL_INTERFACE pRenderHal;
584 MOS_FORMAT format;
585 MOS_TILE_TYPE TileType;
586 uint32_t dwWidth;
587 uint32_t dwHeight;
588 uint32_t dwSize;
589 int32_t i;
590 bool bAllocated;
591 bool bDIEnable;
592 bool bSurfCompressible;
593 bool bFFDNSurfCompressible;
594 bool bFFDISurfCompressible;
595 MOS_RESOURCE_MMC_MODE FFDISurfCompressionMode;
596 MOS_RESOURCE_MMC_MODE SurfCompressionMode;
597 MOS_RESOURCE_MMC_MODE FFDNSurfCompressionMode;
598 MHW_VEBOX_SURFACE_PARAMS MhwVeboxSurfaceParam;
599 PMHW_VEBOX_INTERFACE pVeboxInterface;
600 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
601 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
602 uint8_t InitValue;
603 Mos_MemPool memTypeSurfVideoMem = MOS_MEMPOOL_VIDEOMEMORY;
604 MOS_TILE_MODE_GMM tileModeByForce = MOS_TILE_UNSET_GMM;
605
606 bAllocated = false;
607 bSurfCompressible = false;
608 bFFDNSurfCompressible = false;
609 bFFDISurfCompressible = false;
610 FFDISurfCompressionMode = MOS_MMC_DISABLED;
611 SurfCompressionMode = MOS_MMC_DISABLED;
612 FFDNSurfCompressionMode = MOS_MMC_DISABLED;
613 pOsInterface = pVeboxState->m_pOsInterface;
614 pRenderHal = pVeboxState->m_pRenderHal;
615 pVeboxInterface = pVeboxState->m_pVeboxInterface;
616 InitValue = 0;
617 // change the init value when null hw is enabled
618 VPHAL_RENDER_CHK_NULL(pOsInterface);
619 VPHAL_RENDER_CHK_NULL(pRenderData);
620
621 if (pOsInterface->bNullHwIsEnabled)
622 {
623 InitValue = 0x80;
624 }
625
626 if (MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrLimitedLMemBar))
627 {
628 memTypeSurfVideoMem = MOS_MEMPOOL_DEVICEMEMORY;
629 }
630
631 GetOutputSurfParams(format, TileType);
632
633 // In DN only case, input, output and previous De-noised
634 // surfaces all should have precisely the same memory compression status.
635 // Either all these surfaces should be compressed together
636 // or none of them compressed at all.This is HW limitation.
637 if (IsDNOnly())
638 {
639 bSurfCompressible = pVeboxState->m_currentSurface->bCompressible;
640 SurfCompressionMode = pVeboxState->m_currentSurface->CompressionMode;
641 }
642 // Only Tiled Y surfaces support MMC
643 else if (pVeboxState->bEnableMMC &&
644 (TileType == MOS_TILE_Y) &&
645 IsFormatMMCSupported(format))
646 {
647 bSurfCompressible = true;
648 SurfCompressionMode = MOS_MMC_MC;
649 }
650
651 // Allocate FFDI/IECP surfaces----------------------------------------------
652 if (IsFFDISurfNeeded())
653 {
654 VPHAL_CSPACE ColorSpace;
655 VPHAL_SAMPLE_TYPE SampleType;
656
657 VPHAL_RENDER_CHK_STATUS(GetFFDISurfParams(ColorSpace, SampleType));
658
659 if (SampleType != SAMPLE_PROGRESSIVE)
660 {
661 bFFDISurfCompressible = false;
662 FFDISurfCompressionMode = MOS_MMC_DISABLED;
663 }
664 else
665 {
666 bFFDISurfCompressible = bSurfCompressible;
667 FFDISurfCompressionMode = SurfCompressionMode;
668 }
669
670 for (i = 0; i < pVeboxState->iNumFFDISurfaces; i++)
671 {
672 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
673 pOsInterface,
674 pVeboxState->FFDISurfaces[i],
675 "VeboxFFDISurface_g12",
676 format,
677 MOS_GFXRES_2D,
678 TileType,
679 pVeboxState->m_currentSurface->dwWidth,
680 pVeboxState->m_currentSurface->dwHeight,
681 bFFDISurfCompressible,
682 FFDISurfCompressionMode,
683 &bAllocated,
684 MOS_HW_RESOURCE_DEF_MAX,
685 MOS_TILE_UNSET_GMM,
686 memTypeSurfVideoMem,
687 VPP_INTER_RESOURCE_NOTLOCKABLE));
688
689 pVeboxState->FFDISurfaces[i]->SampleType = SampleType;
690
691 // Copy rect sizes so that if input surface state needs to adjust,
692 // output surface can be adjustted also.
693 pVeboxState->FFDISurfaces[i]->rcSrc = pVeboxState->m_currentSurface->rcSrc;
694 pVeboxState->FFDISurfaces[i]->rcDst = pVeboxState->m_currentSurface->rcDst;
695 // Copy max src rect
696 pVeboxState->FFDISurfaces[i]->rcMaxSrc = pVeboxState->m_currentSurface->rcMaxSrc;
697
698 // Copy Rotation, it's used in setting SFC state
699 pVeboxState->FFDISurfaces[i]->Rotation = pVeboxState->m_currentSurface->Rotation;
700
701 pVeboxState->FFDISurfaces[i]->ColorSpace = ColorSpace;
702
703 // Copy ScalingMode, it's used in setting SFC state
704 pVeboxState->FFDISurfaces[i]->ScalingMode = pVeboxState->m_currentSurface->ScalingMode;
705
706 if (bAllocated)
707 {
708 // Report Compress Status
709 m_reporting->GetFeatures().ffdiCompressible = bSurfCompressible;
710 m_reporting->GetFeatures().ffdiCompressMode = (uint8_t)(SurfCompressionMode);
711 }
712 }
713 }
714 else
715 {
716 // Free FFDI surfaces
717 for (i = 0; i < pVeboxState->iNumFFDISurfaces; i++)
718 {
719 if (pVeboxState->FFDISurfaces[i])
720 {
721 pOsInterface->pfnFreeResource(
722 pOsInterface,
723 &pVeboxState->FFDISurfaces[i]->OsResource);
724 }
725 }
726 }
727
728 // When DI switch to DNDI, the first FFDN surface pitch doesn't match with
729 // the input surface pitch and cause the flicker issue
730 // Or for 2 clip playback in WMP, the first one is HW decoding, the second one is SW decoding,
731 // when the second clip playback starting without media pipeline recreation,
732 // the internal FFDNSurfaces are compressed, but VP input surface is uncompressed.
733 if ((pVeboxState->bDIEnabled && !pVeboxState->bDNEnabled && pRenderData->bDenoise) ||
734 ((pVeboxState->m_currentSurface->bIsCompressed == false) && ((bSurfCompressible == true) || (pVeboxState->FFDNSurfaces[0]->bIsCompressed == true))))
735 {
736 bFFDNSurfCompressible = pVeboxState->m_currentSurface->bCompressible;
737 FFDNSurfCompressionMode = pVeboxState->m_currentSurface->CompressionMode;
738 }
739 else
740 {
741 bFFDNSurfCompressible = bSurfCompressible;
742 FFDNSurfCompressionMode = SurfCompressionMode;
743 }
744
745 tileModeByForce = MOS_TILE_UNSET_GMM;
746 //DN output surface must be tile64 only when input format is bayer
747 if (!MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrTileY) &&
748 IS_BAYER_FORMAT(pVeboxState->m_currentSurface->Format))
749 {
750 VPHAL_RENDER_NORMALMESSAGE("tilemode: media support tile encoding 1");
751 tileModeByForce = MOS_TILE_64_GMM;
752 }
753 // Allocate FFDN surfaces---------------------------------------------------
754 if (IsFFDNSurfNeeded())
755 {
756 for (i = 0; i < VPHAL_NUM_FFDN_SURFACES; i++)
757 {
758 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
759 pOsInterface,
760 pVeboxState->FFDNSurfaces[i],
761 "VeboxFFDNSurface_g12",
762 pVeboxState->m_currentSurface->Format,
763 MOS_GFXRES_2D,
764 pVeboxState->m_currentSurface->TileType,
765 pVeboxState->m_currentSurface->dwWidth,
766 pVeboxState->m_currentSurface->dwHeight,
767 bFFDNSurfCompressible,
768 FFDNSurfCompressionMode,
769 &bAllocated,
770 MOS_HW_RESOURCE_DEF_MAX,
771 tileModeByForce,
772 memTypeSurfVideoMem,
773 VPP_INTER_RESOURCE_NOTLOCKABLE));
774
775 // if allocated, pVeboxState->PreviousSurface is not valid for DN reference.
776 if (bAllocated)
777 {
778 // If DI is enabled, try to use app's reference if provided
779 if (pRenderData->bRefValid &&
780 pRenderData->bDeinterlace &&
781 (pVeboxState->m_currentSurface->pBwdRef != nullptr) &&
782 (pVeboxState->FFDNSurfaces[i]->dwPitch == pVeboxState->m_currentSurface->pBwdRef->dwPitch))
783 {
784 CopySurfaceValue(pVeboxState->m_previousSurface, pVeboxState->m_currentSurface->pBwdRef);
785 }
786 else
787 {
788 pRenderData->bRefValid = false;
789 }
790 }
791
792 // DN's output format should be same to input
793 pVeboxState->FFDNSurfaces[i]->SampleType = pVeboxState->m_currentSurface->SampleType;
794
795 // Copy rect sizes so that if input surface state needs to adjust,
796 // output surface can be adjustted also.
797 pVeboxState->FFDNSurfaces[i]->rcSrc = pVeboxState->m_currentSurface->rcSrc;
798 pVeboxState->FFDNSurfaces[i]->rcDst = pVeboxState->m_currentSurface->rcDst;
799 // Copy max src rect
800 pVeboxState->FFDNSurfaces[i]->rcMaxSrc = pVeboxState->m_currentSurface->rcMaxSrc;
801
802 // Set Colorspace of FFDN
803 pVeboxState->FFDNSurfaces[i]->ColorSpace = pVeboxState->m_currentSurface->ColorSpace;
804
805 // Copy FrameID and parameters, as DN output will be used as next blt's current
806 pVeboxState->FFDNSurfaces[i]->FrameID = pVeboxState->m_currentSurface->FrameID;
807 pVeboxState->FFDNSurfaces[i]->pDenoiseParams = pVeboxState->m_currentSurface->pDenoiseParams;
808 // Copy ScalingMode, it's used in setting SFC state
809 pVeboxState->FFDNSurfaces[i]->ScalingMode = pVeboxState->m_currentSurface->ScalingMode;
810
811 if (bAllocated)
812 {
813 // Report Compress Status
814 m_reporting->GetFeatures().ffdnCompressible = bFFDNSurfCompressible;
815 m_reporting->GetFeatures().ffdnCompressMode = (uint8_t)(FFDNSurfCompressionMode);
816 }
817 }
818 }
819 else
820 {
821 // Free FFDN surfaces
822 for (i = 0; i < VPHAL_NUM_FFDN_SURFACES; i++)
823 {
824 if (pVeboxState->FFDNSurfaces[i])
825 {
826 pOsInterface->pfnFreeResource(
827 pOsInterface,
828 &pVeboxState->FFDNSurfaces[i]->OsResource);
829 }
830 }
831 }
832
833 // Adjust the rcMaxSrc of pRenderTarget when Vebox output is enabled
834 if (IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData))
835 {
836 pRenderData->pRenderTarget->rcMaxSrc = pVeboxState->m_currentSurface->rcMaxSrc;
837 }
838
839 tileModeByForce = MOS_TILE_UNSET_GMM;
840 if (!MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrTileY))
841 {
842 VPHAL_RENDER_NORMALMESSAGE("tilemode: media support tile encoding 1");
843 tileModeByForce = MOS_TILE_64_GMM;
844 }
845 // Allocate STMM (Spatial-Temporal Motion Measure) Surfaces------------------
846 if (IsSTMMSurfNeeded())
847 {
848 bSurfCompressible = false;
849 SurfCompressionMode = MOS_MMC_DISABLED;
850
851 for (i = 0; i < VPHAL_NUM_STMM_SURFACES; i++)
852 {
853 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
854 pOsInterface,
855 &pVeboxState->STMMSurfaces[i],
856 "VeboxSTMMSurface_g12",
857 Format_STMM,
858 MOS_GFXRES_2D,
859 MOS_TILE_Y,
860 pVeboxState->m_currentSurface->dwWidth,
861 pVeboxState->m_currentSurface->dwHeight,
862 bSurfCompressible,
863 SurfCompressionMode,
864 &bAllocated,
865 MOS_HW_RESOURCE_DEF_MAX,
866 tileModeByForce));
867
868 if (bAllocated)
869 {
870 VPHAL_RENDER_CHK_STATUS(VeboxInitSTMMHistory(i));
871
872 // Report Compress Status
873 m_reporting->GetFeatures().stmmCompressible = bSurfCompressible;
874 m_reporting->GetFeatures().stmmCompressMode = (uint8_t)(SurfCompressionMode);
875 }
876 }
877 }
878 else
879 {
880 // Free DI history buffers (STMM = Spatial-temporal motion measure)
881 for (i = 0; i < VPHAL_NUM_STMM_SURFACES; i++)
882 {
883 pOsInterface->pfnFreeResource(
884 pOsInterface,
885 &pVeboxState->STMMSurfaces[i].OsResource);
886 }
887 }
888
889 // Allocate BT2020 CSC temp surface----------------------------------------------
890 if (pRenderData->b2PassesCSC)
891 {
892 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
893 pOsInterface,
894 &pVeboxState->m_BT2020CSCTempSurface,
895 "VeboxBT2020CSCTempSurface_g12",
896 Format_A8B8G8R8,
897 MOS_GFXRES_2D,
898 MOS_TILE_Y,
899 pVeboxState->m_currentSurface->dwWidth,
900 pVeboxState->m_currentSurface->dwHeight,
901 false,
902 MOS_MMC_DISABLED,
903 &bAllocated));
904
905 // Copy rect sizes so that if input surface state needs to adjust,
906 // output surface can be adjustted also.
907 pVeboxState->m_BT2020CSCTempSurface.rcSrc = pVeboxState->m_currentSurface->rcSrc;
908 pVeboxState->m_BT2020CSCTempSurface.rcDst = pVeboxState->m_currentSurface->rcDst;
909 // Copy max src rect
910 pVeboxState->m_BT2020CSCTempSurface.rcMaxSrc = pVeboxState->m_currentSurface->rcMaxSrc;
911
912 // Copy Rotation, it's used in setting SFC state
913 pVeboxState->m_BT2020CSCTempSurface.Rotation = pVeboxState->m_currentSurface->Rotation;
914 pVeboxState->m_BT2020CSCTempSurface.SampleType = pVeboxState->m_currentSurface->SampleType;
915 pVeboxState->m_BT2020CSCTempSurface.ColorSpace = CSpace_sRGB;
916 // Copy ScalingMode, it's used in setting SFC state
917 pVeboxState->m_BT2020CSCTempSurface.ScalingMode = pVeboxState->m_currentSurface->ScalingMode;
918 }
919
920 // Allocate Statistics State Surface----------------------------------------
921 // Width to be a aligned on 64 bytes and height is 1/4 the height
922 // Per frame information written twice per frame for 2 slices
923 // Surface to be a rectangle aligned with dwWidth to get proper dwSize
924 bDIEnable = pRenderData->bDeinterlace || IsQueryVarianceEnabled();
925
926 VPHAL_RENDER_CHK_STATUS(VpHal_InitVeboxSurfaceParams(pVeboxState->m_currentSurface, &MhwVeboxSurfaceParam));
927 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->VeboxAdjustBoundary(
928 &MhwVeboxSurfaceParam,
929 &dwWidth,
930 &dwHeight,
931 bDIEnable));
932
933 dwWidth = MOS_ALIGN_CEIL(dwWidth, 64);
934 dwHeight = MOS_ROUNDUP_DIVIDE(dwHeight, 4) + MOS_ROUNDUP_DIVIDE(VPHAL_VEBOX_STATISTICS_SIZE_G12 * sizeof(uint32_t), dwWidth);
935 dwSize = dwWidth * dwHeight;
936
937 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
938 pOsInterface,
939 &pVeboxState->VeboxStatisticsSurface,
940 "VeboxStatisticsSurface_g12",
941 Format_Buffer,
942 MOS_GFXRES_BUFFER,
943 MOS_TILE_LINEAR,
944 dwSize,
945 1,
946 false,
947 MOS_MMC_DISABLED,
948 &bAllocated));
949
950 if (bAllocated)
951 {
952 // initialize Statistics Surface
953 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnFillResource(
954 pOsInterface,
955 &(pVeboxState->VeboxStatisticsSurface.OsResource),
956 dwSize,
957 InitValue));
958
959 pVeboxState->dwVeboxPerBlockStatisticsWidth = dwWidth;
960 pVeboxState->dwVeboxPerBlockStatisticsHeight = dwHeight - MOS_ROUNDUP_DIVIDE(VPHAL_VEBOX_STATISTICS_SIZE_G12 * sizeof(uint32_t), dwWidth);
961 }
962
963 // Allocate Rgb Histogram surface----------------------------------------------
964 // Size of RGB histograms, 1 set for each slice. For single slice, other set will be 0
965 dwSize = VPHAL_VEBOX_RGB_HISTOGRAM_SIZE_G12;
966 dwSize += VPHAL_VEBOX_RGB_ACE_HISTOGRAM_SIZE_RESERVED_G12;
967 // Size of ACE histograms, 1 set for each slice. For single slice, other set will be 0
968 dwSize += VPHAL_VEBOX_ACE_HISTOGRAM_SIZE_PER_FRAME_PER_SLICE * // Ace histogram size per slice
969 VPHAL_NUM_FRAME_PREVIOUS_CURRENT * // Ace for Prev + Curr
970 VPHAL_VEBOX_HISTOGRAM_SLICES_COUNT; // Total number of slices
971
972 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
973 pOsInterface,
974 &pVeboxState->VeboxRGBHistogram,
975 "VeboxRgbHistogram_g12",
976 Format_Buffer,
977 MOS_GFXRES_BUFFER,
978 MOS_TILE_LINEAR,
979 dwSize,
980 1,
981 false,
982 MOS_MMC_DISABLED,
983 &bAllocated));
984
985 if (bAllocated && pOsInterface->bNullHwIsEnabled)
986 {
987 // Initialize VeboxRGBHistogram Surface
988 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnFillResource(
989 pOsInterface,
990 &(pVeboxState->VeboxRGBHistogram.OsResource),
991 dwSize,
992 InitValue));
993 }
994
995 #if VEBOX_AUTO_DENOISE_SUPPORTED
996 // Allocate Temp Surface for Vebox Update kernels----------------------------------------
997 // the surface size is one Page
998 dwSize = MHW_PAGE_SIZE;
999
1000 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
1001 pOsInterface,
1002 &pVeboxState->VeboxTempSurface,
1003 "VeboxTempSurface_g12",
1004 Format_Buffer,
1005 MOS_GFXRES_BUFFER,
1006 MOS_TILE_LINEAR,
1007 dwSize,
1008 1,
1009 false,
1010 MOS_MMC_DISABLED,
1011 &bAllocated));
1012
1013 if (bAllocated)
1014 {
1015 // initialize Statistics Surface
1016 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnFillResource(
1017 pOsInterface,
1018 &(pVeboxState->VeboxTempSurface.OsResource),
1019 dwSize,
1020 0));
1021 }
1022
1023 // Allocate Spatial Attributes Configuration Surface for DN kernel GEN11-----------
1024 dwSize = MHW_PAGE_SIZE;
1025
1026 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
1027 pOsInterface,
1028 &pVeboxState->VeboxSpatialAttributesConfigurationSurface,
1029 "VeboxSpatialAttributesConfigurationSurface_g12",
1030 Format_RAW,
1031 MOS_GFXRES_BUFFER,
1032 MOS_TILE_LINEAR,
1033 dwSize,
1034 1,
1035 false,
1036 MOS_MMC_DISABLED,
1037 &bAllocated));
1038
1039 if (bAllocated)
1040 {
1041 // initialize Spatial Attributes Configuration Surface
1042 VPHAL_RENDER_CHK_STATUS(VeboxInitSpatialAttributesConfiguration());
1043 }
1044 #endif
1045
1046 if (pRenderData->bHdr3DLut)
1047 {
1048 if (pVeboxState->m_currentSurface->p3DLutParams)
1049 {
1050 pVeboxState->Vebox3DLookUpTables = *(pVeboxState->m_currentSurface->p3DLutParams->pExt3DLutSurface);
1051 }
1052 else
1053 {
1054 // Allocate 3DLut Table Surface
1055 const uint32_t dwSegSize = 65;
1056 const uint32_t dwMulSize = 128;
1057 uint32_t dwSizeInBytes = dwSegSize * dwSegSize * dwMulSize * 8;
1058 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
1059 pOsInterface,
1060 &pVeboxState->Vebox3DLookUpTables,
1061 "Vebox3DLutTableSurface_g12",
1062 Format_Buffer,
1063 MOS_GFXRES_BUFFER,
1064 MOS_TILE_LINEAR,
1065 dwSizeInBytes,
1066 1,
1067 false,
1068 MOS_MMC_DISABLED,
1069 &bAllocated));
1070
1071 if (nullptr == m_hdr3DLutGenerator)
1072 {
1073 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
1074 PRENDERHAL_INTERFACE pRenderHal = pVeboxState->m_pRenderHal;
1075 m_hdr3DLutGenerator = MOS_New(Hdr3DLutGeneratorG12, pRenderHal, m_hdr3DLutKernelBinary, m_hdr3DLutKernelBinarySize);
1076 if (!m_hdr3DLutGenerator->IsObjectVaild())
1077 {
1078 eStatus = MOS_STATUS_NULL_POINTER;
1079 MOS_Delete(m_hdr3DLutGenerator);
1080 VPHAL_RENDER_ASSERTMESSAGE("Failed to creat Hdr3DLutGeneratorG12");
1081 }
1082 #endif
1083 }
1084 }
1085 }
1086
1087 finish:
1088 if (eStatus != MOS_STATUS_SUCCESS)
1089 {
1090 pVeboxState->FreeResources();
1091 }
1092
1093 return eStatus;
1094 }
1095
1096 //!
1097 //! \brief Vebox free resources
1098 //! \details Free resources that are used in Vebox
1099 //! \return void
1100 //!
1101 void VPHAL_VEBOX_STATE_G12_BASE::FreeResources()
1102 {
1103 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
1104 PMOS_INTERFACE pOsInterface = pVeboxState->m_pOsInterface;
1105 VPHAL_RENDER_CHK_NULL_NO_STATUS(pOsInterface);
1106
1107 // Free 3DLook Up table surface which is allocated in VEBOX
1108 // If it is the external surface, the external needs to call free explicitly
1109 // e.g. pVeboxState->m_currentSurface->p3DLutParams->pExt3DLutSurface
1110 // is allocated by App, passed to driver for VEBOX access, this surface should
1111 // be freed by App instead of driver.
1112 if ((pVeboxState->m_currentSurface) &&
1113 (pVeboxState->m_currentSurface->p3DLutParams == NULL))
1114 {
1115 pOsInterface->pfnFreeResource(
1116 pOsInterface,
1117 &pVeboxState->Vebox3DLookUpTables.OsResource);
1118 }
1119
1120 // Free FFDI surfaces
1121 for (int i = 0; i < pVeboxState->iNumFFDISurfaces; i++)
1122 {
1123 if (pVeboxState->FFDISurfaces[i])
1124 {
1125 pOsInterface->pfnFreeResource(
1126 pOsInterface,
1127 &pVeboxState->FFDISurfaces[i]->OsResource);
1128 }
1129 }
1130
1131 // Free FFDN surfaces
1132 for (int i = 0; i < VPHAL_NUM_FFDN_SURFACES; i++)
1133 {
1134 if (pVeboxState->FFDNSurfaces[i])
1135 {
1136 pOsInterface->pfnFreeResource(
1137 pOsInterface,
1138 &pVeboxState->FFDNSurfaces[i]->OsResource);
1139 }
1140 }
1141
1142 // Free DI history buffers (STMM = Spatial-temporal motion measure)
1143 for (int i = 0; i < VPHAL_NUM_STMM_SURFACES; i++)
1144 {
1145 pOsInterface->pfnFreeResource(
1146 pOsInterface,
1147 &pVeboxState->STMMSurfaces[i].OsResource);
1148 }
1149
1150 // Free Statistics data surface for VEBOX
1151 pOsInterface->pfnFreeResource(
1152 pOsInterface,
1153 &pVeboxState->VeboxStatisticsSurface.OsResource);
1154
1155 // Free Rgb Histogram surface for VEBOX
1156 pOsInterface->pfnFreeResource(
1157 pOsInterface,
1158 &pVeboxState->VeboxRGBHistogram.OsResource);
1159
1160 // Free BT2020 CSC temp surface for VEBOX used by BT2020 CSC
1161 pOsInterface->pfnFreeResource(
1162 pOsInterface,
1163 &pVeboxState->m_BT2020CSCTempSurface.OsResource);
1164
1165 #if VEBOX_AUTO_DENOISE_SUPPORTED
1166 // Free Spatial Attributes Configuration Surface for DN kernel
1167 pOsInterface->pfnFreeResource(
1168 pOsInterface,
1169 &pVeboxState->VeboxSpatialAttributesConfigurationSurface.OsResource);
1170
1171 // Free Temp Surface for VEBOX
1172 pOsInterface->pfnFreeResource(
1173 pOsInterface,
1174 &pVeboxState->VeboxTempSurface.OsResource);
1175 #endif
1176
1177 // Free SFC resources
1178 if (MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrSFCPipe) &&
1179 m_sfcPipeState)
1180 {
1181 m_sfcPipeState->FreeResources();
1182 }
1183
1184 MOS_Delete(m_hdr3DLutGenerator);
1185
1186 finish:
1187 return;
1188 }
1189
1190 //!
1191 //! \brief IsMMCEnabledForCurrOutputSurf
1192 //! \details Check if MMC can be enabled for current output surface.
1193 //! \return bool true if suported, otherwise not supported
1194 //!
1195 bool VPHAL_VEBOX_STATE_G12_BASE::IsMMCEnabledForCurrOutputSurf()
1196 {
1197 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1198 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
1199 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData->pRenderTarget);
1200
1201 return bEnableMMC &&
1202 IsFormatMMCSupported(pRenderData->pRenderTarget->Format) &&
1203 (pRenderData->pRenderTarget->CompressionMode != MOS_MMC_DISABLED);
1204
1205 finish:
1206 return false;
1207 }
1208
1209 //!
1210 //! \brief Setup Vebox_DI_IECP Command params for VEBOX final output surface on G9
1211 //! \details Setup Vebox_DI_IECP Command params for VEBOX final output surface on G9
1212 //! \param [in] bDiScdEnable
1213 //! Is DI/Variances report enabled
1214 //! \param [in,out] pVeboxDiIecpCmdParams
1215 //! Pointer to VEBOX_DI_IECP command parameters
1216 //! \return MOS_STATUS
1217 //! Return MOS_STATUS_SUCCESS if successful
1218 //! MOS_STATUS_UNIMPLEMENTED, if condition not implemented,
1219 //! otherwise failed
1220 //!
1221 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetupDiIecpStateForOutputSurf(
1222 bool bDiScdEnable,
1223 PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
1224 {
1225 PVPHAL_SURFACE pSurface;
1226 PMOS_INTERFACE pOsInterface;
1227 PRENDERHAL_INTERFACE pRenderHal;
1228 PMHW_VEBOX_INTERFACE pVeboxInterface;
1229 MHW_VEBOX_SURFACE_CNTL_PARAMS VeboxSurfCntlParams;
1230 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
1231 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1232 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1233
1234 pOsInterface = pVeboxState->m_pOsInterface;
1235 pRenderHal = pVeboxState->m_pRenderHal;
1236 pVeboxInterface = pVeboxState->m_pVeboxInterface;
1237
1238 VPHAL_RENDER_CHK_NULL(pRenderData);
1239 // VEBOX final output surface
1240 if (IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData))
1241 {
1242 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1243 pOsInterface,
1244 &pRenderData->pRenderTarget->OsResource,
1245 true,
1246 true));
1247
1248 pVeboxDiIecpCmdParams->pOsResCurrOutput = &pRenderData->pRenderTarget->OsResource;
1249 pVeboxDiIecpCmdParams->dwCurrOutputSurfOffset = pRenderData->pRenderTarget->dwOffset;
1250 pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.CurrentOutputSurfMemObjCtl;
1251
1252 if (IsMMCEnabledForCurrOutputSurf())
1253 {
1254 // Update control bits for Current Output Surf
1255 pSurface = pRenderData->pRenderTarget;
1256 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1257 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1258 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1259
1260 if (pSurface->OsResource.bUncompressedWriteNeeded)
1261 {
1262 VPHAL_RENDER_NORMALMESSAGE("Vebox uncompressed write needed as previous write need clear ");
1263 VeboxSurfCntlParams.CompressionMode = MOS_MMC_RC;
1264 }
1265
1266 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1267 &VeboxSurfCntlParams,
1268 (uint32_t *)&(pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value)));
1269 }
1270 }
1271 else if (bDiScdEnable)
1272 {
1273 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1274 pOsInterface,
1275 &pVeboxState->FFDISurfaces[pRenderData->iFrame1]->OsResource,
1276 true,
1277 true));
1278
1279 pVeboxDiIecpCmdParams->pOsResCurrOutput = &pVeboxState->FFDISurfaces[pRenderData->iFrame1]->OsResource;
1280 pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.CurrentOutputSurfMemObjCtl;
1281
1282 // Update control bits for Current Output Surf
1283 if (bEnableMMC)
1284 {
1285 pSurface = pVeboxState->FFDISurfaces[pRenderData->iFrame1];
1286 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1287 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1288 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1289 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1290 &VeboxSurfCntlParams,
1291 (uint32_t *)&(pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value)));
1292 }
1293
1294 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1295 pOsInterface,
1296 &pVeboxState->FFDISurfaces[pRenderData->iFrame0]->OsResource,
1297 true,
1298 true));
1299
1300 pVeboxDiIecpCmdParams->pOsResPrevOutput = &pVeboxState->FFDISurfaces[pRenderData->iFrame0]->OsResource;
1301 pVeboxDiIecpCmdParams->PrevOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.CurrentOutputSurfMemObjCtl;
1302
1303 // Update control bits for PrevOutput surface
1304 if (bEnableMMC)
1305 {
1306 pSurface = pVeboxState->FFDISurfaces[pRenderData->iFrame0];
1307 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1308 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1309 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1310 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1311 &VeboxSurfCntlParams,
1312 (uint32_t *)&(pVeboxDiIecpCmdParams->PrevOutputSurfCtrl.Value)));
1313 }
1314 }
1315 else if (IsIECPEnabled()) // IECP output surface without DI
1316 {
1317 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1318 pOsInterface,
1319 &pVeboxState->FFDISurfaces[pRenderData->iCurDNOut]->OsResource,
1320 true,
1321 true));
1322
1323 pVeboxDiIecpCmdParams->pOsResCurrOutput = &pVeboxState->FFDISurfaces[pRenderData->iCurDNOut]->OsResource;
1324 pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.CurrentOutputSurfMemObjCtl;
1325
1326 // Update control bits for CurrOutputSurf surface
1327 if (bEnableMMC)
1328 {
1329 pSurface = pVeboxState->FFDISurfaces[pRenderData->iCurDNOut];
1330 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1331 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1332 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1333 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1334 &VeboxSurfCntlParams,
1335 (uint32_t *)&(pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value)));
1336 }
1337 }
1338 #if (_DEBUG || _RELEASE_INTERNAL)
1339 pRenderHal->oldCacheSettingForTargetSurface = (uint8_t)((pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value >> 1) & 0x0000003f);
1340 #endif
1341
1342 finish:
1343 return eStatus;
1344 }
1345
1346 //!
1347 //! \brief Setup Vebox_DI_IECP Command params for GEN11
1348 //! \details Setup Vebox_DI_IECP Command params for GEN11
1349 //! \param [in] bDiScdEnable
1350 //! Is DI/Variances report enabled
1351 //! \param [in,out] pVeboxDiIecpCmdParams
1352 //! Pointer to VEBOX_DI_IECP command parameters
1353 //! \return MOS_STATUS
1354 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
1355 //!
1356 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetupDiIecpState(
1357 bool bDiScdEnable,
1358 PMHW_VEBOX_DI_IECP_CMD_PARAMS pVeboxDiIecpCmdParams)
1359 {
1360 PMOS_INTERFACE pOsInterface;
1361 PRENDERHAL_INTERFACE pRenderHal;
1362 uint32_t dwWidth;
1363 uint32_t dwHeight;
1364 bool bDIEnable;
1365 MOS_STATUS eStatus;
1366 MHW_VEBOX_SURFACE_PARAMS MhwVeboxSurfaceParam;
1367 PMHW_VEBOX_INTERFACE pVeboxInterface;
1368 MHW_VEBOX_SURFACE_CNTL_PARAMS VeboxSurfCntlParams;
1369 PVPHAL_SURFACE pSurface;
1370 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
1371 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1372
1373 VPHAL_RENDER_CHK_NULL(pVeboxDiIecpCmdParams);
1374 VPHAL_RENDER_CHK_NULL(pVeboxState);
1375 VPHAL_RENDER_CHK_NULL(pRenderData);
1376
1377 pOsInterface = pVeboxState->m_pOsInterface;
1378 pRenderHal = pVeboxState->m_pRenderHal;
1379 pVeboxInterface = pVeboxState->m_pVeboxInterface;
1380 MOS_ZeroMemory(pVeboxDiIecpCmdParams, sizeof(*pVeboxDiIecpCmdParams));
1381
1382 VPHAL_RENDER_CHK_NULL(pOsInterface);
1383 VPHAL_RENDER_CHK_NULL(pRenderHal);
1384 VPHAL_RENDER_CHK_NULL(pVeboxInterface);
1385
1386 // Align dwEndingX with surface state
1387 bDIEnable = pRenderData->bDeinterlace || IsQueryVarianceEnabled();
1388
1389 VPHAL_RENDER_CHK_STATUS(VpHal_InitVeboxSurfaceParams(pVeboxState->m_currentSurface, &MhwVeboxSurfaceParam));
1390 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->VeboxAdjustBoundary(
1391 &MhwVeboxSurfaceParam,
1392 &dwWidth,
1393 &dwHeight,
1394 bDIEnable));
1395
1396 pVeboxDiIecpCmdParams->dwStartingX = 0;
1397 pVeboxDiIecpCmdParams->dwEndingX = dwWidth - 1;
1398
1399 // Input Surface
1400 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1401 pOsInterface,
1402 &pVeboxState->m_currentSurface->OsResource,
1403 false,
1404 true));
1405
1406 pVeboxDiIecpCmdParams->pOsResCurrInput = &pVeboxState->m_currentSurface->OsResource;
1407 pVeboxDiIecpCmdParams->dwCurrInputSurfOffset = pVeboxState->m_currentSurface->dwOffset;
1408 pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.CurrentInputSurfMemObjCtl;
1409
1410 // Update control bits for current surface
1411 if (bEnableMMC)
1412 {
1413 pSurface = pVeboxState->m_currentSurface;
1414 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1415 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1416 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1417 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1418 &VeboxSurfCntlParams,
1419 (uint32_t *)&(pVeboxDiIecpCmdParams->CurrInputSurfCtrl.Value)));
1420 }
1421
1422 // Reference surface
1423 if (pRenderData->bRefValid)
1424 {
1425 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1426 pOsInterface,
1427 &pVeboxState->m_previousSurface->OsResource,
1428 false,
1429 true));
1430
1431 pVeboxDiIecpCmdParams->pOsResPrevInput = &pVeboxState->m_previousSurface->OsResource;
1432 pVeboxDiIecpCmdParams->dwPrevInputSurfOffset = pVeboxState->m_previousSurface->dwOffset;
1433 pVeboxDiIecpCmdParams->PrevInputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.PreviousInputSurfMemObjCtl;
1434
1435 // Update control bits for PreviousSurface surface
1436 if (bEnableMMC)
1437 {
1438 pSurface = pVeboxState->m_previousSurface;
1439 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1440 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1441 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1442 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1443 &VeboxSurfCntlParams,
1444 (uint32_t *)&(pVeboxDiIecpCmdParams->PrevInputSurfCtrl.Value)));
1445 }
1446 }
1447
1448 // VEBOX final output surface
1449 VPHAL_RENDER_CHK_STATUS(SetupDiIecpStateForOutputSurf(bDiScdEnable, pVeboxDiIecpCmdParams));
1450
1451 // DN intermediate output surface
1452 if (IsFFDNSurfNeeded())
1453 {
1454 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1455 pOsInterface,
1456 &pVeboxState->FFDNSurfaces[pRenderData->iCurDNOut]->OsResource,
1457 true,
1458 true));
1459
1460 pVeboxDiIecpCmdParams->pOsResDenoisedCurrOutput = &pVeboxState->FFDNSurfaces[pRenderData->iCurDNOut]->OsResource;
1461 pVeboxDiIecpCmdParams->DenoisedCurrOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.DnOutSurfMemObjCtl;
1462
1463 // Update control bits for DenoisedCurrOutputSurf surface
1464 if (bEnableMMC)
1465 {
1466 pSurface = pVeboxState->FFDNSurfaces[pRenderData->iCurDNOut];
1467 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1468 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1469 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1470 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1471 &VeboxSurfCntlParams,
1472 (uint32_t *)&(pVeboxDiIecpCmdParams->DenoisedCurrOutputSurfCtrl.Value)));
1473 }
1474
1475 // For DN + SFC scenario, allocate FFDISurfaces also
1476 // since this usage needs IECP implicitly
1477 // For DN + DI + SFC, DI have registered FFDISurfaces, So don't register again
1478 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData) && !bDiScdEnable)
1479 {
1480 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1481 pOsInterface,
1482 &pVeboxState->FFDISurfaces[pRenderData->iCurDNOut]->OsResource,
1483 true,
1484 true));
1485
1486 pVeboxDiIecpCmdParams->pOsResCurrOutput = &pVeboxState->FFDISurfaces[pRenderData->iCurDNOut]->OsResource;
1487 pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.CurrentOutputSurfMemObjCtl;
1488
1489 // Update control bits for CurrOutputSurf surface
1490 if (bEnableMMC)
1491 {
1492 pSurface = pVeboxState->FFDISurfaces[pRenderData->iCurDNOut];
1493 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1494 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1495 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1496 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1497 &VeboxSurfCntlParams,
1498 (uint32_t *)&(pVeboxDiIecpCmdParams->CurrOutputSurfCtrl.Value)));
1499 }
1500 }
1501 }
1502
1503 // STMM surface
1504 if (bDiScdEnable || IsSTMMSurfNeeded())
1505 {
1506 // STMM in
1507 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1508 pOsInterface,
1509 &pVeboxState->STMMSurfaces[pRenderData->iCurHistIn].OsResource,
1510 false,
1511 true));
1512
1513 pVeboxDiIecpCmdParams->pOsResStmmInput = &pVeboxState->STMMSurfaces[pRenderData->iCurHistIn].OsResource;
1514 pVeboxDiIecpCmdParams->StmmInputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.STMMInputSurfMemObjCtl;
1515
1516 // Update control bits for stmm input surface
1517 if (bEnableMMC)
1518 {
1519 pSurface = &(pVeboxState->STMMSurfaces[pRenderData->iCurHistIn]);
1520 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1521 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1522 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1523 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1524 &VeboxSurfCntlParams,
1525 (uint32_t *)&(pVeboxDiIecpCmdParams->StmmInputSurfCtrl.Value)));
1526 }
1527
1528 // STMM out
1529 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1530 pOsInterface,
1531 &pVeboxState->STMMSurfaces[pRenderData->iCurHistOut].OsResource,
1532 true,
1533 true));
1534
1535 pVeboxDiIecpCmdParams->pOsResStmmOutput = &pVeboxState->STMMSurfaces[pRenderData->iCurHistOut].OsResource;
1536 pVeboxDiIecpCmdParams->StmmOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.STMMOutputSurfMemObjCtl;
1537
1538 // Update control bits for stmm output surface
1539 if (bEnableMMC)
1540 {
1541 pSurface = &(pVeboxState->STMMSurfaces[pRenderData->iCurHistOut]);
1542 MOS_ZeroMemory(&VeboxSurfCntlParams, sizeof(VeboxSurfCntlParams));
1543 VeboxSurfCntlParams.bIsCompressed = pSurface->bIsCompressed;
1544 VeboxSurfCntlParams.CompressionMode = pSurface->CompressionMode;
1545 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->AddVeboxSurfaceControlBits(
1546 &VeboxSurfCntlParams,
1547 (uint32_t *)&(pVeboxDiIecpCmdParams->StmmOutputSurfCtrl.Value)));
1548 }
1549 }
1550
1551 // Statistics data: GNE, FMD
1552 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1553 pOsInterface,
1554 &pVeboxState->VeboxStatisticsSurface.OsResource,
1555 true,
1556 true));
1557
1558 pVeboxDiIecpCmdParams->pOsResStatisticsOutput = &pVeboxState->VeboxStatisticsSurface.OsResource;
1559 pVeboxDiIecpCmdParams->StatisticsOutputSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.StatisticsOutputSurfMemObjCtl;
1560
1561 if (!Mos_ResourceIsNull(&pVeboxState->VeboxRGBHistogram.OsResource))
1562 {
1563 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
1564 pOsInterface,
1565 &pVeboxState->VeboxRGBHistogram.OsResource,
1566 true,
1567 true));
1568
1569 pVeboxDiIecpCmdParams->pOsResLaceOrAceOrRgbHistogram = &pVeboxState->VeboxRGBHistogram.OsResource;
1570 pVeboxDiIecpCmdParams->LaceOrAceOrRgbHistogramSurfCtrl.Value =
1571 pVeboxState->DnDiSurfMemObjCtl.LaceOrAceOrRgbHistogramSurfCtrl;
1572 }
1573
1574 finish:
1575 return eStatus;
1576 }
1577
1578 //!
1579 //! \brief Vebox query statistics surface layout
1580 //! \details Get Specific Layout Info like GNE Offset, size of per frame info inside
1581 //! Vebox Statistics Surface for CNL
1582 //!
1583 //! | Layout of Statistics surface when DI enabled and DN either On or Off on CNL\n
1584 //! | --------------------------------------------------------------\n
1585 //! | | 16 bytes for x=0, Y=0 | 16 bytes for x=16, Y=0 | ...\n
1586 //! | |-------------------------------------------------------------\n
1587 //! | | 16 bytes for x=0, Y=4 | ...\n
1588 //! | |------------------------------\n
1589 //! | | ...\n
1590 //! | |------------------------------\n
1591 //! | | 16 bytes for x=0, Y=height-4| ...\n
1592 //! | |-----------------------------------------------Pitch--------------\n
1593 //! | | 17 DW Reserved | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
1594 //! | |------------------------------------------------------------------\n
1595 //! | | 11 DW FMD0 | 6 DW GNE0 | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
1596 //! | |------------------------------------------------------------------\n
1597 //! | | 17 DW Reserved | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
1598 //! | |------------------------------------------------------------------\n
1599 //! | | 11 DW FMD1 | 6 DW GNE1 | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
1600 //! | -------------------------------------------------------------------\n
1601 //! |\n
1602 //! | Layout of Statistics surface when DN enabled and DI disabled\n
1603 //! | --------------------------------------------------------------\n
1604 //! | | 16 bytes for x=0, Y=0 | 16 bytes for x=16, Y=0 | ...\n
1605 //! | |-------------------------------------------------------------\n
1606 //! | | 16 bytes for x=0, Y=4 | ...\n
1607 //! | |------------------------------\n
1608 //! | | ...\n
1609 //! | |------------------------------\n
1610 //! | | 16 bytes for x=0, Y=height-4| ...\n
1611 //! | |-----------------------------------------------Pitch--------------\n
1612 //! | | 11 DW FMD0 | 6 DW GNE0 | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
1613 //! | |------------------------------------------------------------------\n
1614 //! | | 11 DW FMD1 | 6 DW GNE1 | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
1615 //! | -------------------------------------------------------------------\n
1616 //! |\n
1617 //! | Layout of Statistics surface when both DN and DI are disabled\n
1618 //! | ------------------------------------------------Pitch--------------\n
1619 //! | | 17 DW White Balence0 | 2 DW STD0 | 2 DW GCC0 | 11 DW Reserved |\n
1620 //! | |------------------------------------------------------------------\n
1621 //! | | 17 DW White Balence1 | 2 DW STD1 | 2 DW GCC1 | 11 DW Reserved |\n
1622 //! | -------------------------------------------------------------------\n
1623 //! \param [in] QueryType
1624 //! Query type
1625 //! \param [out] pQuery
1626 //! return layout type
1627 //! \return MOS_STATUS
1628 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
1629 //!
1630 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::VeboxQueryStatLayout(
1631 VEBOX_STAT_QUERY_TYPE QueryType,
1632 uint32_t* pQuery)
1633 {
1634 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1635
1636 VPHAL_RENDER_ASSERT(pQuery);
1637
1638 switch (QueryType)
1639 {
1640 case VEBOX_STAT_QUERY_GNE_OFFEST:
1641 *pQuery = VPHAL_VEBOX_STATISTICS_SURFACE_GNE_OFFSET_G12;
1642 break;
1643
1644 case VEBOX_STAT_QUERY_PER_FRAME_SIZE:
1645 *pQuery = VPHAL_VEBOX_STATISTICS_PER_FRAME_SIZE_G12;
1646 break;
1647
1648 case VEBOX_STAT_QUERY_FMD_OFFEST:
1649 *pQuery = VPHAL_VEBOX_STATISTICS_SURFACE_FMD_OFFSET_G12;
1650 break;
1651
1652 case VEBOX_STAT_QUERY_STD_OFFEST:
1653 *pQuery = VPHAL_VEBOX_STATISTICS_SURFACE_STD_OFFSET_G12;
1654 break;
1655
1656 default:
1657 VPHAL_RENDER_ASSERTMESSAGE("Vebox Statistics Layout Query, type ('%d') is not implemented.", QueryType);
1658 eStatus = MOS_STATUS_UNKNOWN;
1659 break;
1660 }
1661
1662 return eStatus;
1663 }
1664
1665 //!
1666 //! \brief Vebox get Luma default value
1667 //! \details Initialize luma denoise paramters w/ default values.
1668 //! \param [out] pLumaParams
1669 //! Pointer to Luma DN parameter
1670 //! \return void
1671 //!
1672 void VPHAL_VEBOX_STATE_G12_BASE::GetLumaDefaultValue(
1673 PVPHAL_SAMPLER_STATE_DNDI_PARAM pLumaParams)
1674 {
1675 VPHAL_RENDER_ASSERT(pLumaParams);
1676
1677 pLumaParams->dwDenoiseASDThreshold = NOISE_ABSSUMTEMPORALDIFF_THRESHOLD_DEFAULT_G12;
1678 pLumaParams->dwDenoiseHistoryDelta = NOISE_HISTORY_DELTA_DEFAULT;
1679 pLumaParams->dwDenoiseMaximumHistory = NOISE_HISTORY_MAX_DEFAULT_G12;
1680 pLumaParams->dwDenoiseSTADThreshold = NOISE_SUMABSTEMPORALDIFF_THRESHOLD_DEFAULT_G12;
1681 pLumaParams->dwDenoiseSCMThreshold = NOISE_SPATIALCOMPLEXITYMATRIX_THRESHOLD_DEFAULT_G12;
1682 pLumaParams->dwDenoiseMPThreshold = NOISE_NUMMOTIONPIXELS_THRESHOLD_DEFAULT_G12;
1683 pLumaParams->dwLTDThreshold = NOISE_LOWTEMPORALPIXELDIFF_THRESHOLD_DEFAULT_G12;
1684 pLumaParams->dwTDThreshold = NOISE_TEMPORALPIXELDIFF_THRESHOLD_DEFAULT_G12;
1685 }
1686
1687 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetDNParams(
1688 PVPHAL_SURFACE pSrcSurface,
1689 PVPHAL_SAMPLER_STATE_DNDI_PARAM pLumaParams,
1690 PVPHAL_DNUV_PARAMS pChromaParams)
1691 {
1692 MOS_STATUS eStatus;
1693 PVPHAL_DENOISE_PARAMS pDNParams;
1694 uint32_t dwDenoiseFactor;
1695 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1696
1697 VPHAL_RENDER_CHK_NULL_RETURN(pRenderData);
1698 VPHAL_RENDER_ASSERT(pSrcSurface);
1699 VPHAL_RENDER_ASSERT(pLumaParams);
1700 VPHAL_RENDER_ASSERT(pChromaParams);
1701 VPHAL_RENDER_ASSERT(pRenderData);
1702
1703 eStatus = MOS_STATUS_SUCCESS;
1704 pDNParams = pSrcSurface->pDenoiseParams;
1705
1706 // Set Luma DN params
1707 if (pRenderData->bDenoise)
1708 {
1709 // Setup Denoise Params
1710 GetLumaDefaultValue(pLumaParams);
1711
1712 // Initialize pixel range threshold array
1713 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[0] = NOISE_BLF_RANGE_THRESHOLD_S0_DEFAULT;
1714 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[1] = NOISE_BLF_RANGE_THRESHOLD_S1_DEFAULT;
1715 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[2] = NOISE_BLF_RANGE_THRESHOLD_S2_DEFAULT;
1716 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[3] = NOISE_BLF_RANGE_THRESHOLD_S3_DEFAULT;
1717 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[4] = NOISE_BLF_RANGE_THRESHOLD_S4_DEFAULT;
1718 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[5] = NOISE_BLF_RANGE_THRESHOLD_S5_DEFAULT;
1719
1720 // Initialize pixel range weight array
1721 pRenderData->VeboxDNDIParams.dwPixRangeWeight[0] = NOISE_BLF_RANGE_WGTS0_DEFAULT;
1722 pRenderData->VeboxDNDIParams.dwPixRangeWeight[1] = NOISE_BLF_RANGE_WGTS1_DEFAULT;
1723 pRenderData->VeboxDNDIParams.dwPixRangeWeight[2] = NOISE_BLF_RANGE_WGTS2_DEFAULT;
1724 pRenderData->VeboxDNDIParams.dwPixRangeWeight[3] = NOISE_BLF_RANGE_WGTS3_DEFAULT;
1725 pRenderData->VeboxDNDIParams.dwPixRangeWeight[4] = NOISE_BLF_RANGE_WGTS4_DEFAULT;
1726 pRenderData->VeboxDNDIParams.dwPixRangeWeight[5] = NOISE_BLF_RANGE_WGTS5_DEFAULT;
1727
1728 // User specified Denoise strength case (no auto DN detect)
1729 if (!pDNParams->bAutoDetect)
1730 {
1731 dwDenoiseFactor = (uint32_t)pDNParams->fDenoiseFactor;
1732
1733 if (dwDenoiseFactor > NOISEFACTOR_MAX)
1734 {
1735 dwDenoiseFactor = NOISEFACTOR_MAX;
1736 }
1737
1738 pLumaParams->dwDenoiseHistoryDelta = dwDenoiseHistoryDelta[dwDenoiseFactor];
1739 pLumaParams->dwDenoiseMaximumHistory = dwDenoiseMaximumHistory[dwDenoiseFactor];
1740 pLumaParams->dwDenoiseASDThreshold = dwDenoiseASDThreshold[dwDenoiseFactor];
1741 pLumaParams->dwDenoiseSCMThreshold = dwDenoiseSCMThreshold[dwDenoiseFactor];
1742 pLumaParams->dwDenoiseMPThreshold = dwDenoiseMPThreshold[dwDenoiseFactor];
1743 pLumaParams->dwLTDThreshold = dwLTDThreshold[dwDenoiseFactor];
1744 pLumaParams->dwTDThreshold = dwTDThreshold[dwDenoiseFactor];
1745 pLumaParams->dwDenoiseSTADThreshold = dwDenoiseSTADThreshold[dwDenoiseFactor];
1746
1747 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[0] = dwPixRangeThreshold0[dwDenoiseFactor];
1748 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[1] = dwPixRangeThreshold1[dwDenoiseFactor];
1749 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[2] = dwPixRangeThreshold2[dwDenoiseFactor];
1750 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[3] = dwPixRangeThreshold3[dwDenoiseFactor];
1751 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[4] = dwPixRangeThreshold4[dwDenoiseFactor];
1752 pRenderData->VeboxDNDIParams.dwPixRangeThreshold[5] = dwPixRangeThreshold5[dwDenoiseFactor];
1753
1754 pRenderData->VeboxDNDIParams.dwPixRangeWeight[0] = dwPixRangeWeight0[dwDenoiseFactor];
1755 pRenderData->VeboxDNDIParams.dwPixRangeWeight[1] = dwPixRangeWeight1[dwDenoiseFactor];
1756 pRenderData->VeboxDNDIParams.dwPixRangeWeight[2] = dwPixRangeWeight2[dwDenoiseFactor];
1757 pRenderData->VeboxDNDIParams.dwPixRangeWeight[3] = dwPixRangeWeight3[dwDenoiseFactor];
1758 pRenderData->VeboxDNDIParams.dwPixRangeWeight[4] = dwPixRangeWeight4[dwDenoiseFactor];
1759 pRenderData->VeboxDNDIParams.dwPixRangeWeight[5] = dwPixRangeWeight5[dwDenoiseFactor];
1760 }
1761 }
1762
1763 // Set Chroma DN params
1764 if (pRenderData->bChromaDenoise)
1765 {
1766 // Setup Denoise Params
1767 pChromaParams->dwHistoryDeltaUV = NOISE_HISTORY_DELTA_DEFAULT;
1768 pChromaParams->dwHistoryMaxUV = NOISE_HISTORY_MAX_DEFAULT;
1769
1770 // Denoise Slider case (no auto DN detect)
1771 if (!pDNParams->bAutoDetect)
1772 {
1773 dwDenoiseFactor = (uint32_t)pDNParams->fDenoiseFactor;
1774
1775 if (dwDenoiseFactor > NOISEFACTOR_MAX)
1776 {
1777 dwDenoiseFactor = NOISEFACTOR_MAX;
1778 }
1779
1780 pChromaParams->dwLTDThresholdU =
1781 pChromaParams->dwLTDThresholdV = dwLTDThresholdUV[dwDenoiseFactor];
1782
1783 pChromaParams->dwTDThresholdU =
1784 pChromaParams->dwTDThresholdV = dwTDThresholdUV[dwDenoiseFactor];
1785
1786 pChromaParams->dwSTADThresholdU =
1787 pChromaParams->dwSTADThresholdV = dwSTADThresholdUV[dwDenoiseFactor];
1788 }
1789 }
1790
1791 return eStatus;
1792 }
1793
1794 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetDIParams(
1795 PVPHAL_SURFACE pSrcSurface)
1796 {
1797 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1798 VPHAL_RENDER_CHK_NULL_RETURN(pRenderData);
1799
1800 // Set DI params
1801 if (pRenderData->bDeinterlace)
1802 {
1803 pRenderData->VeboxDNDIParams.dwLumaTDMWeight = VPHAL_VEBOX_DI_LUMA_TDM_WEIGHT_NATUAL;
1804 pRenderData->VeboxDNDIParams.dwChromaTDMWeight = VPHAL_VEBOX_DI_CHROMA_TDM_WEIGHT_NATUAL;
1805 pRenderData->VeboxDNDIParams.dwSHCMDelta = VPHAL_VEBOX_DI_SHCM_DELTA_NATUAL;
1806 pRenderData->VeboxDNDIParams.dwSHCMThreshold = VPHAL_VEBOX_DI_SHCM_THRESHOLD_NATUAL;
1807 pRenderData->VeboxDNDIParams.dwSVCMDelta = VPHAL_VEBOX_DI_SVCM_DELTA_NATUAL;
1808 pRenderData->VeboxDNDIParams.dwSVCMThreshold = VPHAL_VEBOX_DI_SVCM_THRESHOLD_NATUAL;
1809 pRenderData->VeboxDNDIParams.bFasterConvergence = false;
1810 pRenderData->VeboxDNDIParams.bTDMLumaSmallerWindow = false;
1811 pRenderData->VeboxDNDIParams.bTDMChromaSmallerWindow = false;
1812 pRenderData->VeboxDNDIParams.dwLumaTDMCoringThreshold = VPHAL_VEBOX_DI_LUMA_TDM_CORING_THRESHOLD_NATUAL;
1813 pRenderData->VeboxDNDIParams.dwChromaTDMCoringThreshold = VPHAL_VEBOX_DI_CHROMA_TDM_CORING_THRESHOLD_NATUAL;
1814 pRenderData->VeboxDNDIParams.bBypassDeflickerFilter = true;
1815 pRenderData->VeboxDNDIParams.bUseSyntheticContentMedian = false;
1816 pRenderData->VeboxDNDIParams.bLocalCheck = true;
1817 pRenderData->VeboxDNDIParams.bSyntheticContentCheck = false;
1818 pRenderData->VeboxDNDIParams.dwDirectionCheckThreshold = VPHAL_VEBOX_DI_DIRECTION_CHECK_THRESHOLD_NATUAL;
1819 pRenderData->VeboxDNDIParams.dwTearingLowThreshold = VPHAL_VEBOX_DI_TEARING_LOW_THRESHOLD_NATUAL;
1820 pRenderData->VeboxDNDIParams.dwTearingHighThreshold = VPHAL_VEBOX_DI_TEARING_HIGH_THRESHOLD_NATUAL;
1821 pRenderData->VeboxDNDIParams.dwDiffCheckSlackThreshold = VPHAL_VEBOX_DI_DIFF_CHECK_SLACK_THRESHOLD_NATUAL;
1822 pRenderData->VeboxDNDIParams.dwSADWT0 = VPHAL_VEBOX_DI_SAD_WT0_NATUAL;
1823 pRenderData->VeboxDNDIParams.dwSADWT1 = VPHAL_VEBOX_DI_SAD_WT1_NATUAL;
1824 pRenderData->VeboxDNDIParams.dwSADWT2 = VPHAL_VEBOX_DI_SAD_WT2_NATUAL;
1825 pRenderData->VeboxDNDIParams.dwSADWT3 = VPHAL_VEBOX_DI_SAD_WT3_NATUAL;
1826 pRenderData->VeboxDNDIParams.dwSADWT4 = VPHAL_VEBOX_DI_SAD_WT4_NATUAL;
1827 pRenderData->VeboxDNDIParams.dwSADWT6 = VPHAL_VEBOX_DI_SAD_WT6_NATUAL;
1828 if (pSrcSurface && pSrcSurface->pDeinterlaceParams)
1829 {
1830 pRenderData->VeboxDNDIParams.bSCDEnable = pSrcSurface->pDeinterlaceParams->bSCDEnable;
1831 }
1832 else
1833 {
1834 pRenderData->VeboxDNDIParams.bSCDEnable = false;
1835 }
1836
1837 VPHAL_RENDER_CHK_NULL_RETURN(pSrcSurface);
1838 if (MEDIA_IS_HDCONTENT(pSrcSurface->dwWidth, pSrcSurface->dwHeight))
1839 {
1840 pRenderData->VeboxDNDIParams.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_HD_NATUAL;
1841 pRenderData->VeboxDNDIParams.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_HD_NATUAL;
1842 pRenderData->VeboxDNDIParams.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_HD_NATUAL;
1843 pRenderData->VeboxDNDIParams.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_HD_NATUAL;
1844 pRenderData->VeboxDNDIParams.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_HD_NATUAL;
1845 pRenderData->VeboxDNDIParams.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_HD_NATUAL;
1846 pRenderData->VeboxDNDIParams.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_HD_NATUAL;
1847 pRenderData->VeboxDNDIParams.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_HD_NATUAL;
1848 }
1849 else
1850 {
1851 pRenderData->VeboxDNDIParams.dwLPFWtLUT0 = VPHAL_VEBOX_DI_LPFWTLUT0_SD_NATUAL;
1852 pRenderData->VeboxDNDIParams.dwLPFWtLUT1 = VPHAL_VEBOX_DI_LPFWTLUT1_SD_NATUAL;
1853 pRenderData->VeboxDNDIParams.dwLPFWtLUT2 = VPHAL_VEBOX_DI_LPFWTLUT2_SD_NATUAL;
1854 pRenderData->VeboxDNDIParams.dwLPFWtLUT3 = VPHAL_VEBOX_DI_LPFWTLUT3_SD_NATUAL;
1855 pRenderData->VeboxDNDIParams.dwLPFWtLUT4 = VPHAL_VEBOX_DI_LPFWTLUT4_SD_NATUAL;
1856 pRenderData->VeboxDNDIParams.dwLPFWtLUT5 = VPHAL_VEBOX_DI_LPFWTLUT5_SD_NATUAL;
1857 pRenderData->VeboxDNDIParams.dwLPFWtLUT6 = VPHAL_VEBOX_DI_LPFWTLUT6_SD_NATUAL;
1858 pRenderData->VeboxDNDIParams.dwLPFWtLUT7 = VPHAL_VEBOX_DI_LPFWTLUT7_SD_NATUAL;
1859 }
1860 }
1861
1862 return MOS_STATUS_SUCCESS;
1863 }
1864
1865 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetDNDIParams(
1866 PVPHAL_SURFACE pSrcSurface,
1867 PVPHAL_SAMPLER_STATE_DNDI_PARAM pLumaParams,
1868 PVPHAL_DNUV_PARAMS pChromaParams)
1869 {
1870 MOS_STATUS status;
1871
1872 VPHAL_RENDER_ASSERT(pSrcSurface);
1873 VPHAL_RENDER_ASSERT(pLumaParams);
1874 VPHAL_RENDER_ASSERT(pChromaParams);
1875
1876 status = MOS_STATUS_SUCCESS;
1877
1878 status = SetDNParams(pSrcSurface, pLumaParams, pChromaParams);
1879
1880 MOS_STATUS status2 = SetDIParams(pSrcSurface);
1881
1882 if (MOS_SUCCEEDED(status))
1883 {
1884 status = status2;
1885 }
1886
1887 return status;
1888 }
1889
1890 //!
1891 //! \brief Get output surface of Vebox
1892 //! \details Get output surface of Vebox in current operation
1893 //! \param [in] bDiVarianceEnable
1894 //! Is DI/Variances report enabled
1895 //! \return PVPHAL_SURFACE
1896 //! Corresponding output surface pointer
1897 //!
1898 PVPHAL_SURFACE VPHAL_VEBOX_STATE_G12_BASE::GetSurfOutput(
1899 bool bDiVarianceEnable)
1900 {
1901 PVPHAL_SURFACE pSurface = nullptr;
1902 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
1903 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1904
1905 if (!pRenderData)
1906 {
1907 VPHAL_RENDER_ASSERTMESSAGE("pRenderData is null");
1908 return nullptr;
1909 }
1910
1911 if (IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData)) // Vebox output pipe
1912 {
1913 pSurface = pRenderData->pRenderTarget;
1914 }
1915 else if (bDiVarianceEnable) // DNDI, DI, DI + IECP
1916 {
1917 pSurface = pVeboxState->FFDISurfaces[pRenderData->iFrame0];
1918 }
1919 else if (IsIECPEnabled()) // DN + IECP or IECP only
1920 {
1921 pSurface = pVeboxState->FFDISurfaces[pRenderData->iCurDNOut];
1922 }
1923 else if (pRenderData->bDenoise) // DN only
1924 {
1925 pSurface = pVeboxState->FFDNSurfaces[pRenderData->iCurDNOut];
1926 }
1927 else if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData)) // Write to SFC
1928 {
1929 // Vebox o/p should not be written to memory
1930 pSurface = nullptr;
1931 }
1932 else
1933 {
1934 VPHAL_RENDER_ASSERTMESSAGE("Unable to determine Vebox Output Surface.");
1935 }
1936
1937 return pSurface;
1938 }
1939
1940 //!
1941 //! \brief Setup surface states for Vebox
1942 //! \details Setup surface states for use in the current Vebox Operation
1943 //! \param [in] bDiVarianceEnable
1944 //! Is DI/Variances report enabled
1945 //! \param [in,out] pVeboxSurfaceStateCmdParams
1946 //! Pointer to VEBOX_SURFACE_STATE command parameters
1947 //! \return void
1948 //!
1949 void VPHAL_VEBOX_STATE_G12_BASE::SetupSurfaceStates(
1950 bool bDiVarianceEnable,
1951 PVPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS pVeboxSurfaceStateCmdParams)
1952 {
1953 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
1954 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1955
1956 VPHAL_RENDER_CHK_NULL_NO_STATUS_RETURN(pRenderData);
1957 MOS_ZeroMemory(pVeboxSurfaceStateCmdParams, sizeof(VPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS));
1958
1959 pVeboxSurfaceStateCmdParams->pSurfInput = pVeboxState->m_currentSurface;
1960 pVeboxSurfaceStateCmdParams->pSurfOutput = pVeboxState->GetSurfOutput(bDiVarianceEnable);
1961 pVeboxSurfaceStateCmdParams->pSurfSTMM = &pVeboxState->STMMSurfaces[pRenderData->iCurHistIn];
1962 pVeboxSurfaceStateCmdParams->pSurfDNOutput = pVeboxState->FFDNSurfaces[pRenderData->iCurDNOut];
1963 pVeboxSurfaceStateCmdParams->bDIEnable = bDiVarianceEnable;
1964 pVeboxSurfaceStateCmdParams->b3DlutEnable = pRenderData->bHdr3DLut;
1965
1966 }
1967
1968 bool VPHAL_VEBOX_STATE_G12_BASE::UseKernelResource()
1969 {
1970 return false; // can always use driver resource in clear memory
1971 }
1972
1973 //!
1974 //! \brief Setup Chroma Sampling for Vebox
1975 //! \details Setup Chroma Sampling for use in the current Vebox Operation
1976 //! \param pChromaSampling
1977 //! [in] Pointer to chroma sampling params of Vebox
1978 //! \return void
1979 //!
1980 void VPHAL_VEBOX_STATE_G12_BASE::SetupChromaSampling(
1981 PMHW_VEBOX_CHROMA_SAMPLING pChromaSampling)
1982 {
1983 VPHAL_COLORPACK srcColorPack = VPHAL_COLORPACK_420;
1984 VPHAL_COLORPACK dstColorPack = VPHAL_COLORPACK_420;
1985 PVPHAL_SURFACE pSrcSurface = nullptr;
1986 PVPHAL_SURFACE pRenderTarget = nullptr;
1987 bool bDIEnabled = false;
1988 bool bNeedUpSampling = false;
1989 bool bNeedDownSampling = false;
1990 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
1991 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
1992
1993 VPHAL_RENDER_CHK_NULL_NO_STATUS(pVeboxState);
1994 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
1995 VPHAL_RENDER_CHK_NULL_NO_STATUS(pChromaSampling);
1996
1997 // Initialize VEBOX chroma sitting to bypass
1998 pChromaSampling->BypassChromaUpsampling = 1;
1999 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = 0;
2000 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = 0;
2001 pChromaSampling->BypassChromaDownsampling = 1;
2002 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = 0;
2003 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = 0;
2004
2005 // IECP need 444 input, so we use VEBOX CUS to do upsampling.
2006 bNeedUpSampling = pRenderData->bIECP;
2007 // Only VEBOX output, we use VEO to do downsampling.
2008 // Else, we use SFC/FC path to do downscaling.
2009 // if VEBOX intermediate buffer format is non_YUY2 on DI case, enable downsampling as center-left
2010 if (pRenderData->bDeinterlace && (pRenderData->pRenderTarget->Format != Format_YUY2))
2011 {
2012 bNeedDownSampling = true;
2013 }
2014 else
2015 {
2016 bNeedDownSampling = IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData);
2017 }
2018
2019 // Source
2020 pSrcSurface = pVeboxState->m_currentSurface;
2021 // Currently, if no input, we also don't set chroma sitting on render target.
2022 VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrcSurface);
2023 // Source Chroma sitting default
2024 if (pSrcSurface->ChromaSiting == MHW_CHROMA_SITING_NONE)
2025 {
2026 pSrcSurface->ChromaSiting = (CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_CENTER);
2027 }
2028 srcColorPack = VpHalDDIUtils::GetSurfaceColorPack(pSrcSurface->Format);
2029 switch (srcColorPack)
2030 {
2031 // For 422 format, vertical should be always 0.
2032 case VPHAL_COLORPACK_422:
2033 pSrcSurface->ChromaSiting = (pSrcSurface->ChromaSiting & 0x7) | CHROMA_SITING_VERT_TOP;
2034 break;
2035 // For 444 format, we always default to left & top because Luma and Chroma is co-sited.
2036 case VPHAL_COLORPACK_444:
2037 pSrcSurface->ChromaSiting = CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_TOP;
2038 break;
2039 default:
2040 break;
2041 }
2042
2043 // Handle source chroma sitting
2044 if (bNeedUpSampling)
2045 {
2046 bDIEnabled = pRenderData->bDeinterlace;
2047 // Type 0
2048 if ((pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_LEFT) &&
2049 (pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_CENTER))
2050 {
2051 if (srcColorPack == VPHAL_COLORPACK_420)
2052 {
2053 pChromaSampling->BypassChromaUpsampling = 0;
2054 if (bDIEnabled)
2055 {
2056 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE0_HORZ_OFFSET;
2057 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE0_VERT_OFFSET;
2058 }
2059 else
2060 {
2061 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE0_HORZ_OFFSET;
2062 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE0_VERT_OFFSET;
2063 }
2064 }
2065 }
2066 // Type 1
2067 else if ((pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) &&
2068 (pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_CENTER))
2069 {
2070 if (srcColorPack == VPHAL_COLORPACK_420)
2071 {
2072 pChromaSampling->BypassChromaUpsampling = 0;
2073 if (bDIEnabled)
2074 {
2075 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE1_HORZ_OFFSET;
2076 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE1_VERT_OFFSET;
2077 }
2078 else
2079 {
2080 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE1_HORZ_OFFSET;
2081 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE1_VERT_OFFSET;
2082 }
2083 }
2084 }
2085 // Type 2
2086 else if ((pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_LEFT) &&
2087 (pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP))
2088 {
2089 if (srcColorPack == VPHAL_COLORPACK_420)
2090 {
2091 pChromaSampling->BypassChromaUpsampling = 0;
2092 if (bDIEnabled)
2093 {
2094 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE2_HORZ_OFFSET;
2095 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE2_VERT_OFFSET;
2096 }
2097 else
2098 {
2099 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE2_HORZ_OFFSET;
2100 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE2_VERT_OFFSET;
2101 }
2102 }
2103 else if (srcColorPack == VPHAL_COLORPACK_422)
2104 {
2105 pChromaSampling->BypassChromaUpsampling = 0;
2106 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_422_TYPE2_HORZ_OFFSET;
2107 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_422_TYPE2_VERT_OFFSET;
2108 }
2109 }
2110 // Type 3
2111 else if ((pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) &&
2112 (pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP))
2113 {
2114 if (srcColorPack == VPHAL_COLORPACK_420)
2115 {
2116 pChromaSampling->BypassChromaUpsampling = 0;
2117 if (bDIEnabled)
2118 {
2119 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE3_HORZ_OFFSET;
2120 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE3_VERT_OFFSET;
2121 }
2122 else
2123 {
2124 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE3_HORZ_OFFSET;
2125 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE3_VERT_OFFSET;
2126 }
2127 }
2128 else if (srcColorPack == VPHAL_COLORPACK_422)
2129 {
2130 pChromaSampling->BypassChromaUpsampling = 0;
2131 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_422_TYPE3_HORZ_OFFSET;
2132 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_422_TYPE3_VERT_OFFSET;
2133 }
2134 }
2135 // Type 4
2136 else if ((pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_LEFT) &&
2137 (pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM))
2138 {
2139 if (srcColorPack == VPHAL_COLORPACK_420)
2140 {
2141 pChromaSampling->BypassChromaUpsampling = 0;
2142 if (bDIEnabled)
2143 {
2144 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE4_HORZ_OFFSET;
2145 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE4_VERT_OFFSET;
2146 }
2147 else
2148 {
2149 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE4_HORZ_OFFSET;
2150 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE4_VERT_OFFSET;
2151 }
2152 }
2153 }
2154 // Type 5
2155 else if ((pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) &&
2156 (pSrcSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM))
2157 {
2158 if (srcColorPack == VPHAL_COLORPACK_420)
2159 {
2160 pChromaSampling->BypassChromaUpsampling = 0;
2161 if (bDIEnabled)
2162 {
2163 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE5_HORZ_OFFSET;
2164 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITH_DI_TYPE5_VERT_OFFSET;
2165 }
2166 else
2167 {
2168 pChromaSampling->ChromaUpsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE5_HORZ_OFFSET;
2169 pChromaSampling->ChromaUpsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_UPSAMPLING_420_WITHOUT_DI_TYPE5_VERT_OFFSET;
2170 }
2171 }
2172 }
2173 }
2174
2175 // Render Target
2176 pRenderTarget = pRenderData->pRenderTarget;
2177 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderTarget);
2178 if (pRenderTarget->ChromaSiting == MHW_CHROMA_SITING_NONE)
2179 {
2180 pRenderTarget->ChromaSiting = (CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_CENTER);
2181 }
2182 dstColorPack = VpHalDDIUtils::GetSurfaceColorPack(pRenderTarget->Format);
2183 switch (dstColorPack)
2184 {
2185 case VPHAL_COLORPACK_422:
2186 // For 422 format, vertical should be always 0.
2187 pRenderTarget->ChromaSiting = (pRenderTarget->ChromaSiting & 0x7) | CHROMA_SITING_VERT_TOP;
2188 break;
2189 case VPHAL_COLORPACK_444:
2190 // For 444 format, we always default to left & top because Luma and Chroma is co-sited.
2191 pRenderTarget->ChromaSiting = CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_TOP;
2192 break;
2193 default:
2194 break;
2195 }
2196
2197 // Handle render target chroma sitting
2198 if (bNeedDownSampling)
2199 {
2200 // Type 0
2201 if ((pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_HORZ_LEFT) &&
2202 (pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_VERT_CENTER))
2203 {
2204 if (dstColorPack == VPHAL_COLORPACK_420)
2205 {
2206 pChromaSampling->BypassChromaDownsampling = 0;
2207 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE0_HORZ_OFFSET;
2208 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE0_VERT_OFFSET;
2209 }
2210 }
2211 // Type 1
2212 else if ((pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) &&
2213 (pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_VERT_CENTER))
2214 {
2215 if (dstColorPack == VPHAL_COLORPACK_420)
2216 {
2217 pChromaSampling->BypassChromaDownsampling = 0;
2218 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE1_HORZ_OFFSET;
2219 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE1_VERT_OFFSET;
2220 }
2221 }
2222 // Type 2
2223 else if ((pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_HORZ_LEFT) &&
2224 (pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP))
2225 {
2226 if (dstColorPack == VPHAL_COLORPACK_420)
2227 {
2228 pChromaSampling->BypassChromaDownsampling = 0;
2229 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE2_HORZ_OFFSET;
2230 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE2_VERT_OFFSET;
2231 }
2232 else if (dstColorPack == VPHAL_COLORPACK_422)
2233 {
2234 pChromaSampling->BypassChromaDownsampling = 0;
2235 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_422_TYPE2_HORZ_OFFSET;
2236 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_422_TYPE2_VERT_OFFSET;
2237 }
2238 }
2239 // Type 3
2240 else if ((pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) &&
2241 (pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_VERT_TOP))
2242 {
2243 if (dstColorPack == VPHAL_COLORPACK_420)
2244 {
2245 pChromaSampling->BypassChromaDownsampling = 0;
2246 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE3_HORZ_OFFSET;
2247 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE3_VERT_OFFSET;
2248 }
2249 else if (dstColorPack == VPHAL_COLORPACK_422)
2250 {
2251 pChromaSampling->BypassChromaDownsampling = 0;
2252 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_422_TYPE3_HORZ_OFFSET;
2253 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_422_TYPE3_VERT_OFFSET;
2254 }
2255 }
2256 // Type 4
2257 else if ((pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_HORZ_LEFT) &&
2258 (pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM))
2259 {
2260 if (dstColorPack == VPHAL_COLORPACK_420)
2261 {
2262 pChromaSampling->BypassChromaDownsampling = 0;
2263 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE4_HORZ_OFFSET;
2264 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE4_VERT_OFFSET;
2265 }
2266 }
2267 // Type 5
2268 else if ((pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) &&
2269 (pRenderTarget->ChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM))
2270 {
2271 if (dstColorPack == VPHAL_COLORPACK_420)
2272 {
2273 pChromaSampling->BypassChromaDownsampling = 0;
2274 pChromaSampling->ChromaDownsamplingCoSitedHorizontalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE5_HORZ_OFFSET;
2275 pChromaSampling->ChromaDownsamplingCoSitedVerticalOffset = VPHAL_VEBOX_CHROMA_DOWNSAMPLING_420_TYPE5_VERT_OFFSET;
2276 }
2277 }
2278 }
2279
2280 finish:
2281 return;
2282 }
2283
2284 //!
2285 //! \brief Setup Vebox_State Command parameter
2286 //! \param [in] bDiVarianceEnable
2287 //! Is DI/Variances report enabled
2288 //! \param [in,out] pVeboxStateCmdParams
2289 //! Pointer to VEBOX_STATE command parameters
2290 //! \return MOS_STATUS
2291 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
2292 //!
2293 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetupVeboxState(
2294 bool bDiVarianceEnable,
2295 PMHW_VEBOX_STATE_CMD_PARAMS pVeboxStateCmdParams)
2296 {
2297 PMHW_VEBOX_MODE pVeboxMode = nullptr;
2298 PMOS_INTERFACE pOsInterface = nullptr;
2299 PMHW_VEBOX_3D_LUT pLUT3D = nullptr;
2300 uint8_t* p3DLutData = nullptr;
2301 uint32_t dw3DLutDataSize = 0;
2302 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2303 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
2304 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
2305
2306 VPHAL_RENDER_CHK_NULL(pVeboxStateCmdParams);
2307 VPHAL_RENDER_CHK_NULL(pVeboxState);
2308 VPHAL_RENDER_CHK_NULL(pRenderData);
2309
2310 pVeboxMode = &pVeboxStateCmdParams->VeboxMode;
2311 pOsInterface = pVeboxState->m_pOsInterface;
2312
2313 VPHAL_RENDER_CHK_NULL(pVeboxMode);
2314 VPHAL_RENDER_CHK_NULL(pOsInterface);
2315
2316 pLUT3D = &pVeboxStateCmdParams->LUT3D;
2317
2318 MOS_ZeroMemory(pVeboxStateCmdParams, sizeof(*pVeboxStateCmdParams));
2319
2320 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData) ||
2321 IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData))
2322 {
2323 // On CNL, GlobalIECP must be enabled when the output pipe is Vebox or SFC
2324 pVeboxMode->GlobalIECPEnable = true;
2325 }
2326 else
2327 {
2328 pVeboxMode->GlobalIECPEnable = IsIECPEnabled();
2329 }
2330
2331 pVeboxMode->DIEnable = bDiVarianceEnable;
2332 pVeboxMode->SFCParallelWriteEnable = IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData) && (pRenderData->bDenoise || bDiVarianceEnable);
2333 pVeboxMode->DNEnable = pRenderData->bDenoise;
2334 pVeboxMode->DNDIFirstFrame = (!pRenderData->bRefValid && (pVeboxMode->DNEnable || pVeboxMode->DIEnable));
2335 pVeboxMode->DIOutputFrames = SetDIOutputFrame(pRenderData, pVeboxState, pVeboxMode);
2336 pVeboxMode->DisableEncoderStatistics = true;
2337
2338 if((pVeboxMode->DIEnable == false) &&
2339 (pVeboxMode->DNEnable != false) &&
2340 ((pVeboxState->bDisableTemporalDenoiseFilter) ||
2341 (IS_RGB_CSPACE(pVeboxState->m_currentSurface->ColorSpace))))
2342 {
2343 pVeboxMode->DisableTemporalDenoiseFilter = true;
2344 // GlobalIECP or Demosaic must be enabled even if IECP not used
2345 pVeboxMode->GlobalIECPEnable = true;
2346 }
2347 else
2348 {
2349 pVeboxMode->DisableTemporalDenoiseFilter = false;
2350 }
2351
2352 pVeboxStateCmdParams->bUseVeboxHeapKernelResource = UseKernelResource();
2353
2354 SetupChromaSampling(&pVeboxStateCmdParams->ChromaSampling);
2355
2356 if (MEDIA_IS_SKU(pVeboxState->m_pRenderHal->pSkuTable, FtrSingleVeboxSlice))
2357 {
2358 pVeboxMode->SingleSliceVeboxEnable = 0;
2359 }
2360 else
2361 {
2362 // Permanent program limitation that should go in all the configurations of SKLGT which have 2 VEBOXes (i.e. GT3 & GT4)
2363 // VEBOX1 should be disabled whenever there is an VE-SFC workload.
2364 // This is because we have only one SFC all the GT configurations and that SFC is tied to VEBOX0. Hence the programming restriction.
2365 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData))
2366 {
2367 pVeboxMode->SingleSliceVeboxEnable = 1;
2368 }
2369 else
2370 {
2371 pVeboxMode->SingleSliceVeboxEnable = 0;
2372 }
2373 }
2374
2375 if (pRenderData->bHdr3DLut && pLUT3D)
2376 {
2377 pVeboxMode->ColorGamutExpansionEnable = true;
2378
2379 // Set Vebox 3D Look Up Table Surfaces
2380 pVeboxStateCmdParams->pVebox3DLookUpTables = &pVeboxState->Vebox3DLookUpTables.OsResource;
2381 VPHAL_RENDER_CHK_STATUS(pOsInterface->pfnRegisterResource(
2382 pOsInterface,
2383 &pVeboxState->Vebox3DLookUpTables.OsResource,
2384 false,
2385 true));
2386 pVeboxStateCmdParams->Vebox3DLookUpTablesSurfCtrl.Value = pVeboxState->DnDiSurfMemObjCtl.Vebox3DLookUpTablesSurfMemObjCtl;
2387
2388 pLUT3D->ArbitrationPriorityControl = 0;
2389 pLUT3D->Lut3dEnable = true;
2390 pLUT3D->Lut3dSize = 2;
2391
2392 if (pVeboxState->m_currentSurface->p3DLutParams)
2393 {
2394 if (pVeboxState->m_currentSurface->p3DLutParams->LutSize == 17)
2395 {
2396 pLUT3D->Lut3dSize = 1;
2397 }
2398 else if (pVeboxState->m_currentSurface->p3DLutParams->LutSize == 33)
2399 {
2400 pLUT3D->Lut3dSize = 0;
2401 }
2402 else if (pVeboxState->m_currentSurface->p3DLutParams->LutSize == 65)
2403 {
2404 pLUT3D->Lut3dSize = 2;
2405 }
2406 }
2407 else
2408 {
2409 if (m_hdr3DLutGenerator)
2410 {
2411 m_hdr3DLutGenerator->Render(
2412 pRenderData->uiMaxDisplayLum,
2413 pRenderData->uiMaxContentLevelLum,
2414 pRenderData->hdrMode,
2415 &pVeboxState->Vebox3DLookUpTables);
2416 }
2417 // 65^3 is the default.
2418 pLUT3D->Lut3dSize = 2;
2419 }
2420 }
2421
2422 finish:
2423 return eStatus;
2424 }
2425
2426 VPHAL_OUTPUT_PIPE_MODE VPHAL_VEBOX_STATE_G12_BASE::GetOutputPipe(
2427 PCVPHAL_RENDER_PARAMS pcRenderParams,
2428 PVPHAL_SURFACE pSrcSurface,
2429 RenderpassData* pRenderData)
2430
2431 {
2432 VPHAL_OUTPUT_PIPE_MODE OutputPipe;
2433 bool bCompBypassFeasible = false;
2434 bool bOutputPipeVeboxFeasible = false;
2435 bool bHDRToneMappingNeed = false;
2436 PVPHAL_SURFACE pTarget = nullptr;
2437 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
2438
2439 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
2440
2441 VPHAL_RENDER_CHK_NULL_NO_STATUS(pcRenderParams);
2442 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
2443 VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrcSurface);
2444 VPHAL_RENDER_CHK_NULL_NO_STATUS(pcRenderParams->pTarget[0]);
2445
2446 pTarget = pcRenderParams->pTarget[0];
2447
2448 bCompBypassFeasible = IS_COMP_BYPASS_FEASIBLE(pRenderData->bCompNeeded, pcRenderParams, pSrcSurface);
2449
2450 if (!bCompBypassFeasible)
2451 {
2452 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
2453 goto finish;
2454 }
2455
2456 //Let Kernel to cover the DI cases VEBOX cannot handle.
2457 if (pSrcSurface->pDeinterlaceParams &&
2458 pSrcSurface->pDeinterlaceParams->DIMode == DI_MODE_BOB &&
2459 ((IS_VEBOX_SURFACE_HEIGHT_UNALIGNED(pSrcSurface, 4) &&
2460 (pSrcSurface->Format == Format_P010 ||
2461 pSrcSurface->Format == Format_P016 ||
2462 pSrcSurface->Format == Format_NV12)) ||
2463 !this->IsDiFormatSupported(pSrcSurface)))
2464 {
2465 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
2466 goto finish;
2467 }
2468
2469 // Let Kernel to output P010 instead of VEBOX output
2470 if (pSrcSurface->p3DLutParams &&
2471 (pTarget->Format == Format_P010 ||
2472 pTarget->Format == Format_P016))
2473 {
2474 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
2475 goto finish;
2476 }
2477
2478 bOutputPipeVeboxFeasible = IS_OUTPUT_PIPE_VEBOX_FEASIBLE(pVeboxState, pcRenderParams, pSrcSurface);
2479 if (bOutputPipeVeboxFeasible)
2480 {
2481 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_VEBOX;
2482 goto finish;
2483 }
2484
2485 if (VeboxIs2PassesCSCNeeded(pSrcSurface, pcRenderParams->pTarget[0]))
2486 {
2487 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
2488 goto finish;
2489 }
2490
2491 bHDRToneMappingNeed = (pSrcSurface->pHDRParams || pTarget->pHDRParams);
2492 // Check if SFC can be the output pipe
2493 if (m_sfcPipeState && !bHDRToneMappingNeed)
2494 {
2495 OutputPipe = m_sfcPipeState->GetOutputPipe(pSrcSurface, pTarget, pcRenderParams);
2496 }
2497 else
2498 {
2499 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
2500 }
2501
2502 // Explore the potential to still output by VEBOX and perform quick color fill in composition
2503 if (bCompBypassFeasible &&
2504 OutputPipe == VPHAL_OUTPUT_PIPE_MODE_COMP &&
2505 pcRenderParams->pColorFillParams &&
2506 pSrcSurface->rcDst.left == pTarget->rcDst.left &&
2507 pSrcSurface->rcDst.top == pTarget->rcDst.top &&
2508 pSrcSurface->rcDst.right == pTarget->rcDst.right &&
2509 pSrcSurface->rcDst.bottom < pTarget->rcDst.bottom)
2510 {
2511 int32_t lTargetBottom;
2512 lTargetBottom = pTarget->rcDst.bottom;
2513 pTarget->rcDst.bottom = pSrcSurface->rcDst.bottom;
2514
2515 // Check if Vebox can be the output pipe again
2516 bOutputPipeVeboxFeasible = IS_OUTPUT_PIPE_VEBOX_FEASIBLE(pVeboxState, pcRenderParams, pSrcSurface);
2517 if (bOutputPipeVeboxFeasible)
2518 {
2519 OutputPipe = VPHAL_OUTPUT_PIPE_MODE_VEBOX;
2520 pTarget->bFastColorFill = true;
2521
2522 if (pTarget->bIsCompressed &&
2523 pTarget->CompressionMode == MOS_MMC_MC &&
2524 (pSrcSurface->rcDst.bottom - pSrcSurface->rcDst.top) % 8 != 0)
2525 {
2526 //If FastColorFill is enabled, pTarget will be shared by VE and Render
2527 //Upper rectangle in pTarget will be used by VE
2528 //Bottom rectangle in pTarget will be used by Render
2529 //If upper rectangle height is not a multiple of 8 unit When MMC is enabled,
2530 //we need to decompress the target surface to avoid output corruption
2531 MOS_STATUS eStatus = m_pOsInterface->pfnDecompResource(m_pOsInterface, &pTarget->OsResource);
2532 if(eStatus == MOS_STATUS_SUCCESS)
2533 {
2534 pTarget->bIsCompressed = false;
2535 pTarget->CompressionMode = MOS_MMC_DISABLED;
2536 pTarget->CompressionFormat = 0;
2537 }
2538 else
2539 {
2540 VPHAL_RENDER_ASSERTMESSAGE("FastColorFill is enabled and decompress target surface failed");
2541 }
2542 }
2543 }
2544 pTarget->rcDst.bottom = lTargetBottom;
2545 }
2546
2547 finish:
2548 pRenderData->bCompNeeded = (OutputPipe == VPHAL_OUTPUT_PIPE_MODE_COMP) ? true : false;
2549 return OutputPipe;
2550 }
2551
2552 //!
2553 //! \brief Vebox is needed on Gen12
2554 //! \details Check if Vebox Render operation can be applied
2555 //! \param [in] pcRenderParams
2556 //! Pointer to VpHal render parameters
2557 //! \param [in,out] pRenderPassData
2558 //! Pointer to Render data
2559 //! \return bool
2560 //! return true if Vebox is needed, otherwise false
2561 //!
2562 bool VPHAL_VEBOX_STATE_G12_BASE::IsNeeded(
2563 PCVPHAL_RENDER_PARAMS pcRenderParams,
2564 RenderpassData *pRenderPassData)
2565 {
2566 PVPHAL_VEBOX_RENDER_DATA pRenderData;
2567 PRENDERHAL_INTERFACE pRenderHal;
2568 PVPHAL_SURFACE pRenderTarget;
2569 bool bVeboxNeeded;
2570 PMOS_INTERFACE pOsInterface;
2571 MOS_STATUS eStatus;
2572 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
2573 PVPHAL_SURFACE pSrcSurface = nullptr;
2574 bool bEnableIEF;
2575
2576 bVeboxNeeded = false;
2577 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal);
2578 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
2579
2580 pRenderHal = pVeboxState->m_pRenderHal;
2581 pOsInterface = pVeboxState->m_pOsInterface;
2582
2583 pRenderTarget = pcRenderParams->pTarget[0];
2584 pRenderData = GetLastExecRenderData();
2585 pSrcSurface = pRenderPassData->pSrcSurface;
2586
2587 VPHAL_RENDER_CHK_NULL(pSrcSurface);
2588 VPHAL_RENDER_CHK_NULL(pRenderData);
2589
2590 // Check whether VEBOX is available
2591 // VTd doesn't support VEBOX
2592 if (!MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrVERing))
2593 {
2594 pRenderPassData->bCompNeeded = true;
2595 goto finish;
2596 }
2597
2598 // Check if the Surface size is greater than 64x16 which is the minimum Width and Height VEBOX can handle
2599 if (pSrcSurface->dwWidth < MHW_VEBOX_MIN_WIDTH || pSrcSurface->dwHeight < MHW_VEBOX_MIN_HEIGHT)
2600 {
2601 pRenderPassData->bCompNeeded = true;
2602 goto finish;
2603 }
2604
2605 //Force 8K to render
2606 if (pcRenderParams->bDisableVeboxFor8K &&
2607 ((pSrcSurface->dwWidth >= VPHAL_RNDR_8K_WIDTH || pSrcSurface->dwHeight >= VPHAL_RNDR_8K_HEIGHT) ||
2608 (pRenderTarget->dwWidth >= VPHAL_RNDR_8K_WIDTH || pRenderTarget->dwHeight >= VPHAL_RNDR_8K_HEIGHT)))
2609 {
2610 // For HDR/Vebox Scalability, still need Vebox to handle since there is no fallback Render path.
2611 if (!pcRenderParams->pSrc[0]->pHDRParams && !pcRenderParams->pTarget[0]->pHDRParams &&
2612 !pOsInterface->bVeboxScalabilityMode)
2613 {
2614 VPHAL_RENDER_NORMALMESSAGE("Disable VEBOX/SFC for 8k resolution");
2615 pRenderPassData->bCompNeeded = true;
2616 goto finish;
2617 }
2618 }
2619
2620 // Force NV12 16K to render
2621 if (pRenderTarget->Format == Format_NV12 && pRenderTarget->dwHeight > VPHAL_RNDR_16K_HEIGHT_LIMIT)
2622 {
2623 VPHAL_RENDER_NORMALMESSAGE("Disable VEBOX/SFC for NV12 16k resolution");
2624 pRenderPassData->bCompNeeded = true;
2625 goto finish;
2626 }
2627
2628 pRenderData->Init();
2629 if (MEDIA_IS_SKU(m_pSkuTable, FtrSFCPipe) && m_sfcPipeState)
2630 {
2631 m_sfcPipeState->InitRenderData();
2632 }
2633
2634 bEnableIEF = (pSrcSurface->pIEFParams && pSrcSurface->pIEFParams->bEnabled == true) ? true : false;
2635
2636 // We need to change the output pipe priority of SFC on GEN12 Linux due to IEF has been removed from AVS sampler
2637 if (pSrcSurface->ScalingPreference == VPHAL_SCALING_PREFER_COMP && bEnableIEF)
2638 {
2639 VPHAL_RENDER_NORMALMESSAGE("Driver set ScalingPreference to SFC to cover IEF.");
2640 pSrcSurface->ScalingPreference = VPHAL_SCALING_PREFER_SFC;
2641 }
2642
2643 // Determine the output pipe before setting the rendering flags for Vebox and SFC
2644 SET_VPHAL_OUTPUT_PIPE(
2645 pRenderData,
2646 GetOutputPipe(
2647 pcRenderParams,
2648 pSrcSurface,
2649 pRenderPassData));
2650
2651 if (IS_VPHAL_OUTPUT_PIPE_INVALID(pRenderData))
2652 {
2653 VPHAL_RENDER_ASSERTMESSAGE("Invalid output pipe!");
2654 bVeboxNeeded = false;
2655 goto finish;
2656 }
2657
2658 //If using Vebox to Crop, setting the bVEBOXCroppingUsed = true. We use the rcSrc to set Vebox width/height instead of using rcMaxsrc in VeboxAdjustBoundary().
2659 if (IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData) &&
2660 ((uint32_t)pSrcSurface->rcSrc.bottom < pSrcSurface->dwHeight ||
2661 (uint32_t)pSrcSurface->rcSrc.right < pSrcSurface->dwWidth))
2662 {
2663 pSrcSurface->bVEBOXCroppingUsed = true;
2664 pRenderTarget->bVEBOXCroppingUsed = true;
2665 VPHAL_RENDER_NORMALMESSAGE("bVEBOXCroppingUsed = true, pSrcSurface->rcSrc.bottom: %d, pSrcSurface->rcSrc.right: %d; pSrcSurface->dwHeight: %d, pSrcSurface->dwHeight: %d;",
2666 (uint32_t)pSrcSurface->rcSrc.bottom,
2667 (uint32_t)pSrcSurface->rcSrc.right,
2668 pSrcSurface->dwHeight,
2669 pSrcSurface->dwWidth);
2670 }
2671 else
2672 {
2673 pSrcSurface->bVEBOXCroppingUsed = false;
2674 pRenderTarget->bVEBOXCroppingUsed = false;
2675 }
2676
2677 // Set MMC State
2678 SET_VPHAL_MMC_STATE(pRenderData, pVeboxState->bEnableMMC);
2679
2680 // Update execution state based on current and past events such as the
2681 // # of future and past frames available.
2682 pVeboxState->UpdateVeboxExecutionState(
2683 pSrcSurface,
2684 pRenderData->OutputPipe);
2685
2686 // Set Component
2687 SET_VPHAL_COMPONENT(pRenderData, pcRenderParams->Component);
2688
2689 // Check if Vebox can be used to process the surface
2690 if (pVeboxState->IsFormatSupported(pSrcSurface))
2691 {
2692 // Save Alpha passed by App to be used in Vebox
2693 if (IS_VPHAL_OUTPUT_PIPE_VEBOX(pRenderData))
2694 {
2695 pRenderData->pAlphaParams = pcRenderParams->pCompAlpha;
2696 }
2697
2698 // Setup Rendering Flags for Vebox
2699 VeboxSetRenderingFlags(
2700 pSrcSurface,
2701 pRenderTarget);
2702
2703 if (pRenderData->b2PassesCSC)
2704 {
2705 pRenderData->bVeboxBypass = false;
2706 }
2707
2708 // Vebox is needed if Vebox isn't bypassed
2709 bVeboxNeeded = !pRenderData->bVeboxBypass;
2710 }
2711
2712 // if ScalingPreference == VPHAL_SCALING_PREFER_SFC_FOR_VEBOX, use SFC only when VEBOX is required
2713 // For GEN12+, IEF has been removed from AVS sampler and do not change the path if IEF is enabled.
2714 if ((pSrcSurface->ScalingPreference == VPHAL_SCALING_PREFER_SFC_FOR_VEBOX) &&
2715 (!bEnableIEF) &&
2716 (bVeboxNeeded == false))
2717 {
2718 VPHAL_RENDER_NORMALMESSAGE("DDI choose to use SFC only for VEBOX, and since VEBOX is not required, change to Composition.");
2719 pRenderData->OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
2720 pRenderPassData->bCompNeeded = true;
2721 }
2722
2723 // Check if we want to enable SFC processing
2724 if (IS_VPHAL_OUTPUT_PIPE_SFC(pRenderData))
2725 {
2726 // Setup Rendering Flags for SFC pipe
2727 m_sfcPipeState->SetRenderingFlags(
2728 pcRenderParams->pColorFillParams,
2729 pcRenderParams->pCompAlpha,
2730 pSrcSurface,
2731 pRenderTarget,
2732 pRenderData);
2733
2734 // Update Vebox Rendering Flags when the output pipe is SFC.
2735 // If input surface format is AYUV, and just have one layer as primary, Procamp can also enable.
2736 // Those flags cannot be updated inside Vebox's SetRenderingFlags due to ScalingPreference option will
2737 // turn back to composition when Vebox is not needed in above code.
2738 pRenderData->bProcamp = (IS_YUV_FORMAT(pSrcSurface->Format) ||
2739 (pSrcSurface->Format == Format_AYUV &&
2740 pcRenderParams->uSrcCount == 1)) &&
2741 pSrcSurface->pProcampParams &&
2742 pSrcSurface->pProcampParams->bEnabled;
2743 pRenderData->bBeCsc = IS_RGB_CSPACE(pSrcSurface->ColorSpace);
2744 pRenderData->bIECP = pRenderData->bIECP ||
2745 pRenderData->bProcamp ||
2746 pRenderData->bBeCsc;
2747
2748 bVeboxNeeded = true;
2749 }
2750
2751 finish:
2752 return bVeboxNeeded;
2753 }
2754
2755 //!
2756 //! \brief Vebox get the back-end colorspace conversion matrix
2757 //! \details When the i/o is A8R8G8B8 or X8R8G8B8, the transfer matrix
2758 //! needs to be updated accordingly
2759 //! \param [in] pSrcSurface
2760 //! Pointer to input surface of Vebox
2761 //! \param [in] pOutSurface
2762 //! Pointer to output surface of Vebox
2763 //! \return void
2764 //!
2765 void VPHAL_VEBOX_STATE_G12_BASE::VeboxGetBeCSCMatrix(
2766 PVPHAL_SURFACE pSrcSurface,
2767 PVPHAL_SURFACE pOutSurface)
2768 {
2769 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
2770 float fTemp[3];
2771
2772 // Get the matrix to use for conversion
2773 VpHal_GetCscMatrix(
2774 pSrcSurface->ColorSpace,
2775 pOutSurface->ColorSpace,
2776 pVeboxState->fCscCoeff,
2777 pVeboxState->fCscInOffset,
2778 pVeboxState->fCscOutOffset);
2779
2780 // Vebox CSC converts RGB input to YUV for SFC
2781 // Vebox only supports A8B8G8R8 input, swap the 1st and 3rd
2782 // columns of the transfer matrix for A8R8G8B8 and X8R8G8B8
2783 // This only happens when SFC output is used
2784 if ((pSrcSurface->Format == Format_A8R8G8B8) ||
2785 (pSrcSurface->Format == Format_X8R8G8B8))
2786 {
2787 fTemp[0] = pVeboxState->fCscCoeff[0];
2788 fTemp[1] = pVeboxState->fCscCoeff[3];
2789 fTemp[2] = pVeboxState->fCscCoeff[6];
2790
2791 pVeboxState->fCscCoeff[0] = pVeboxState->fCscCoeff[2];
2792 pVeboxState->fCscCoeff[3] = pVeboxState->fCscCoeff[5];
2793 pVeboxState->fCscCoeff[6] = pVeboxState->fCscCoeff[8];
2794
2795 pVeboxState->fCscCoeff[2] = fTemp[0];
2796 pVeboxState->fCscCoeff[5] = fTemp[1];
2797 pVeboxState->fCscCoeff[8] = fTemp[2];
2798 }
2799 }
2800
2801 #if VEBOX_AUTO_DENOISE_SUPPORTED
2802 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::LoadUpdateDenoiseKernelStaticData(
2803 int32_t *iCurbeOffsetOutDN)
2804 {
2805 PRENDERHAL_INTERFACE pRenderHal;
2806 VEBOX_STATE_UPDATE_STATIC_DATA_G12 DNStaticData; // DN Update kernelStatic parameters
2807 PMHW_VEBOX_INTERFACE pVeboxInterface;
2808 PVPHAL_DENOISE_PARAMS pDenoiseParams; // Denoise
2809 int32_t iOffset0, iOffset1, iOffset2, iOffset3;
2810 int32_t iPitch;
2811 MOS_STATUS eStatus;
2812 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
2813
2814 VPHAL_RENDER_CHK_NULL(pRenderData);
2815 VPHAL_RENDER_CHK_NULL(iCurbeOffsetOutDN);
2816
2817 pRenderHal = m_pRenderHal;
2818 pVeboxInterface = m_pVeboxInterface;
2819 eStatus = MOS_STATUS_SUCCESS;
2820
2821 // init the static data
2822 MOS_ZeroMemory(&DNStaticData, sizeof(DNStaticData));
2823
2824 pDenoiseParams = m_currentSurface->pDenoiseParams;
2825 VPHAL_RENDER_ASSERT(pDenoiseParams);
2826
2827 // Get offset for slice0 and slice1
2828 VPHAL_RENDER_CHK_STATUS(VeboxGetStatisticsSurfaceOffsets(
2829 &iOffset0,
2830 &iOffset1));
2831
2832 iPitch = iOffset1 - iOffset0;
2833 iOffset2 = iOffset1 + iPitch;
2834 iOffset3 = iOffset2 + iPitch;
2835
2836 // Load DN update kernel CURBE data
2837 if (pRenderData->bAutoDenoise)
2838 {
2839 // set the curbe data for DN update kernel
2840 DNStaticData.DW00.OffsetToSlice0 = iOffset0;
2841 DNStaticData.DW01.OffsetToSlice1 = iOffset1;
2842 DNStaticData.DW02.OffsetToSlice2 = iOffset2;
2843 DNStaticData.DW03.OffsetToSlice3 = iOffset3;
2844 DNStaticData.DW04.FirstFrameFlag = bFirstFrame;
2845 DNStaticData.DW04.NoiseLevel = pDenoiseParams->NoiseLevel;
2846 DNStaticData.DW05.RangeThrAdp2NLvl = 1;
2847 DNStaticData.DW06.VeboxStatisticsSurface = BI_DN_STATISTICS_SURFACE;
2848 DNStaticData.DW07.VeboxDndiStateSurface = BI_DN_VEBOX_STATE_SURFACE;
2849 DNStaticData.DW08.VeboxTempSurface = BI_DN_TEMP_SURFACE;
2850 DNStaticData.DW09.VeboxSpatialAttributesConfigurationSurface = BI_DN_SPATIAL_ATTRIBUTES_CONFIGURATION_SURFACE;
2851
2852 *iCurbeOffsetOutDN = pRenderHal->pfnLoadCurbeData(
2853 pRenderHal,
2854 pRenderData->pMediaState,
2855 &DNStaticData,
2856 sizeof(DNStaticData));
2857
2858 if (*iCurbeOffsetOutDN < 0)
2859 {
2860 eStatus = MOS_STATUS_UNKNOWN;
2861 goto finish;
2862 }
2863
2864 pRenderData->iCurbeLength += sizeof(DNStaticData);
2865 }
2866
2867 finish:
2868 return eStatus;
2869 }
2870 //!
2871 //! \brief Setup surface states for Denoise
2872 //! \details Setup Surface State for Vebox States Auto DN kernel
2873 //! \return MOS_STATUS
2874 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
2875 //!
2876 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetupSurfaceStatesForDenoise()
2877 {
2878 PRENDERHAL_INTERFACE pRenderHal;
2879 PMOS_INTERFACE pOsInterface;
2880 RENDERHAL_SURFACE_STATE_PARAMS SurfaceParams;
2881 MOS_STATUS eStatus;
2882 MOS_FORMAT tmpFormat;
2883 bool bUseKernelResource;
2884 const MHW_VEBOX_HEAP *pVeboxHeap = nullptr;
2885 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
2886 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
2887
2888 VPHAL_RENDER_CHK_NULL(pVeboxState);
2889 VPHAL_RENDER_CHK_NULL(pRenderData);
2890 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pRenderHal);
2891 VPHAL_RENDER_CHK_NULL(pVeboxState->m_pOsInterface);
2892
2893 eStatus = MOS_STATUS_SUCCESS;
2894 pRenderHal = pVeboxState->m_pRenderHal;
2895 pOsInterface = pVeboxState->m_pOsInterface;
2896 VPHAL_RENDER_CHK_STATUS(pVeboxState->m_pVeboxInterface->GetVeboxHeapInfo(&pVeboxHeap));
2897 VPHAL_RENDER_CHK_NULL(pVeboxHeap);
2898
2899 bUseKernelResource = UseKernelResource();
2900
2901 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2902 MOS_ZeroMemory(&pVeboxState->VeboxHeapResource, sizeof(VPHAL_SURFACE));
2903 MOS_ZeroMemory(&pVeboxState->tmpResource, sizeof(VPHAL_SURFACE));
2904
2905 // Treat the 1D buffer as 2D surface
2906 // VEBox State Surface
2907 pVeboxState->VeboxHeapResource.Format = Format_L8;
2908 pVeboxState->VeboxHeapResource.dwWidth = SECURE_BLOCK_COPY_KERNEL_SURF_WIDTH; // Hard code for secure Block Copy kernel
2909 pVeboxState->VeboxHeapResource.dwPitch = SECURE_BLOCK_COPY_KERNEL_SURF_WIDTH; // Hard code for secure Block Copy kernel
2910 pVeboxState->VeboxHeapResource.dwHeight = MOS_ROUNDUP_DIVIDE(pVeboxHeap->uiInstanceSize, SECURE_BLOCK_COPY_KERNEL_SURF_WIDTH);
2911 pVeboxState->VeboxHeapResource.dwOffset = pVeboxHeap->uiInstanceSize * pVeboxHeap->uiCurState;
2912 pVeboxState->VeboxHeapResource.TileType = MOS_TILE_LINEAR;
2913 pVeboxState->VeboxHeapResource.OsResource = bUseKernelResource ? pVeboxHeap->KernelResource : pVeboxHeap->DriverResource;
2914
2915 // Temp Surface: for Noise Level History
2916 pVeboxState->tmpResource.Format = Format_L8;
2917 pVeboxState->tmpResource.dwWidth = SECURE_BLOCK_COPY_KERNEL_SURF_WIDTH; // Hard code for secure Block Copy kernel
2918 pVeboxState->tmpResource.dwPitch = SECURE_BLOCK_COPY_KERNEL_SURF_WIDTH; // Hard code for secure Block Copy kernel
2919 pVeboxState->tmpResource.dwHeight = MOS_ROUNDUP_DIVIDE(MHW_PAGE_SIZE, SECURE_BLOCK_COPY_KERNEL_SURF_WIDTH);
2920 pVeboxState->tmpResource.dwOffset = 0;
2921 pVeboxState->tmpResource.TileType = MOS_TILE_LINEAR;
2922 pVeboxState->tmpResource.OsResource = pVeboxState->VeboxTempSurface.OsResource;
2923
2924 // Statistics Surface-----------------------------------------------------------
2925 tmpFormat = pVeboxState->VeboxStatisticsSurface.Format;
2926 pVeboxState->VeboxStatisticsSurface.Format = Format_RAW;
2927
2928 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetBufferSurfaceForHwAccess(
2929 pRenderHal,
2930 &pVeboxState->VeboxStatisticsSurface,
2931 &pVeboxState->RenderHalVeboxStatisticsSurface,
2932 nullptr,
2933 pRenderData->iBindingTable,
2934 BI_DN_STATISTICS_SURFACE,
2935 false));
2936
2937 pVeboxState->VeboxStatisticsSurface.Format = tmpFormat;
2938
2939 // VEBox State Surface-----------------------------------------------------------
2940 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2941
2942 SurfaceParams.Type = pRenderHal->SurfaceTypeDefault;
2943 SurfaceParams.isOutput = true;
2944 SurfaceParams.bWidthInDword_Y = true;
2945 SurfaceParams.bWidthInDword_UV = true;
2946 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
2947 SurfaceParams.bWidth16Align = false;
2948 SurfaceParams.MemObjCtl = (pRenderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
2949 MOS_MP_RESOURCE_USAGE_DEFAULT,
2950 pRenderHal->pOsInterface->pfnGetGmmClientContext(pRenderHal->pOsInterface))).DwordValue;
2951
2952 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetSurfaceForHwAccess(
2953 pRenderHal,
2954 &pVeboxState->VeboxHeapResource,
2955 &pVeboxState->RenderHalVeboxHeapResource,
2956 &SurfaceParams,
2957 pRenderData->iBindingTable,
2958 BI_DN_VEBOX_STATE_SURFACE,
2959 true));
2960
2961 // VEBox Temp Surface-----------------------------------------------------------
2962 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2963
2964 SurfaceParams.Type = pRenderHal->SurfaceTypeDefault;
2965 SurfaceParams.isOutput = true;
2966 SurfaceParams.bWidthInDword_Y = true;
2967 SurfaceParams.bWidthInDword_UV = true;
2968 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
2969 SurfaceParams.bWidth16Align = false;
2970 SurfaceParams.MemObjCtl = (pRenderHal->pOsInterface->pfnCachePolicyGetMemoryObject(
2971 MOS_MP_RESOURCE_USAGE_DEFAULT,
2972 pRenderHal->pOsInterface->pfnGetGmmClientContext(pRenderHal->pOsInterface))).DwordValue;
2973
2974 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetSurfaceForHwAccess(
2975 pRenderHal,
2976 &pVeboxState->tmpResource,
2977 &pVeboxState->RenderHalTmpResource,
2978 &SurfaceParams,
2979 pRenderData->iBindingTable,
2980 BI_DN_TEMP_SURFACE,
2981 true));
2982
2983 // Spatial Attributes Configuration Surface------------------------------------
2984 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2985
2986 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetBufferSurfaceForHwAccess(
2987 pRenderHal,
2988 &pVeboxState->VeboxSpatialAttributesConfigurationSurface,
2989 &pVeboxState->RenderHalVeboxSpatialAttributesConfigurationSurface,
2990 &SurfaceParams,
2991 pRenderData->iBindingTable,
2992 BI_DN_SPATIAL_ATTRIBUTES_CONFIGURATION_SURFACE,
2993 false));
2994
2995 finish:
2996 return eStatus;
2997 }
2998 #endif
2999
3000 //!
3001 //! \brief Setup kernels for Vebox auto mode features
3002 //! \details Setup kernels that co-operate with Vebox auto mode features
3003 //! \param [in] iKDTIndex
3004 //! Index to Kernel Parameter Array (defined platform specific)
3005 //! \return MOS_STATUS
3006 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
3007 //!
3008 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::SetupVeboxKernel(
3009 int32_t iKDTIndex)
3010 {
3011 Kdll_CacheEntry *pCacheEntryTable; // Kernel Cache Entry table
3012 Kdll_FilterEntry *pFilter; // Kernel Filter (points to base of filter array)
3013 int32_t iKUID; // Kernel Unique ID (DNDI uses combined kernels)
3014 int32_t iInlineLength; // Inline data length
3015 MOS_STATUS eStatus; // Return code
3016 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
3017 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
3018 VPHAL_RENDER_CHK_NULL(pRenderData);
3019 // Initialize Variables
3020 eStatus = MOS_STATUS_SUCCESS;
3021 pFilter = &pVeboxState->SearchFilter[0];
3022 pCacheEntryTable = pVeboxState->m_pKernelDllState->ComponentKernelCache.pCacheEntries;
3023
3024 // Initialize States
3025 MOS_ZeroMemory(pFilter, sizeof(pVeboxState->SearchFilter));
3026 MOS_ZeroMemory(&pRenderData->KernelEntry[iKDTIndex], sizeof(Kdll_CacheEntry));
3027
3028 #if VEBOX_AUTO_DENOISE_SUPPORTED
3029 if (iKDTIndex == KERNEL_UPDATEDNSTATE)
3030 {
3031 iKUID = IDR_VP_UpdateDNState;
3032 iInlineLength = 0; // No inline data
3033 pRenderData->PerfTag = VPHAL_VEBOX_UPDATE_DN_STATE;
3034 }
3035 else // Incorrect index to kernel parameters array
3036 #endif
3037 {
3038 VPHAL_RENDER_ASSERTMESSAGE("Incorrect index to kernel parameters array.");
3039 eStatus = MOS_STATUS_UNKNOWN;
3040 goto finish;
3041 }
3042
3043 // Store pointer to Kernel Parameter
3044 pRenderData->pKernelParam[iKDTIndex] = &pVeboxState->pKernelParamTable[iKDTIndex];
3045
3046 // Set Parameters for Kernel Entry
3047 pRenderData->KernelEntry[iKDTIndex].iKUID = iKUID;
3048 pRenderData->KernelEntry[iKDTIndex].iKCID = -1;
3049 pRenderData->KernelEntry[iKDTIndex].iFilterSize = 2;
3050 pRenderData->KernelEntry[iKDTIndex].pFilter = pFilter;
3051 pRenderData->KernelEntry[iKDTIndex].iSize = pCacheEntryTable[iKUID].iSize;
3052 pRenderData->KernelEntry[iKDTIndex].pBinary = pCacheEntryTable[iKUID].pBinary;
3053
3054 // set the Inline Data length
3055 pRenderData->iInlineLength = iInlineLength;
3056
3057 VPHAL_RENDER_NORMALMESSAGE("Vebox Kernels: %s", g_KernelDNDI_Str_g12[iKDTIndex]);
3058
3059 finish:
3060 return eStatus;
3061 }
3062
3063 //!
3064 //! \brief Vebox set rendering flag
3065 //! \details Setup Rendering Flags due to different usage case - main entrance
3066 //! \param [in] pSrc
3067 //! Pointer to input surface of Vebox
3068 //! \param [in] pRenderTarget
3069 //! Pointer to Render target surface of VPP BLT
3070 //! \return void
3071 //!
3072 void VPHAL_VEBOX_STATE_G12_BASE::VeboxSetRenderingFlags(
3073 PVPHAL_SURFACE pSrc,
3074 PVPHAL_SURFACE pRenderTarget)
3075 {
3076 bool bToneMapping = false;
3077 PVPHAL_VEBOX_RENDER_DATA pRenderData = GetLastExecRenderData();
3078
3079 VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrc);
3080 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderTarget);
3081 VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderData);
3082
3083 if ((pSrc->pHDRParams && (pSrc->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR)) ||
3084 (pRenderTarget->pHDRParams && (pRenderTarget->pHDRParams->EOTF != VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR)))
3085 {
3086 bToneMapping = true;
3087 }
3088 pRenderData->bHdr3DLut = bToneMapping;
3089 pRenderData->bHdr3DLut |= (pSrc->p3DLutParams != nullptr);
3090 VPHAL_RENDER_NORMALMESSAGE("Enable 3DLut for HDR ToneMapping %d or 3DLUT filter %d.", bToneMapping, (pSrc->p3DLutParams != nullptr));
3091 MT_LOG1(MT_VP_HAL_RENDER_VE, MT_NORMAL, MT_VP_RENDERDATA_HDR3DLUT, pRenderData->bHdr3DLut);
3092
3093 VPHAL_VEBOX_STATE::VeboxSetRenderingFlags(pSrc, pRenderTarget);
3094
3095 finish:
3096 return;
3097 }
3098
3099 //!
3100 //! \brief Render the Vebox Cmd buffer for VeboxSendVeboxCmd
3101 //! Parameters might remain unchanged in case
3102 //! \param [in,out] CmdBuffer
3103 //! reference to Cmd buffer control struct
3104 //! \param [out] VeboxDiIecpCmdParams
3105 //! DiIecpCmd params struct to be set
3106 //! \param [out] VeboxSurfaceStateCmdParams
3107 //! VPHAL surface state cmd to be set
3108 //! \param [out] MhwVeboxSurfaceStateCmdParams
3109 //! MHW surface state cmd to be set
3110 //! \param [out] VeboxStateCmdParams
3111 //! MHW vebox state cmd to be set
3112 //! \param [out] FlushDwParams
3113 //! MHW MI_FLUSH_DW cmd to be set
3114 //! \param [in] pGenericPrologParams
3115 //! pointer to Generic prolog params struct to send to cmd buffer header
3116 //! \return MOS_STATUS
3117 //! Return MOS_STATUS_SUCCESS if successful, otherwise failed
3118 //!
3119 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::VeboxRenderVeboxCmd(
3120 MOS_COMMAND_BUFFER& CmdBuffer,
3121 MHW_VEBOX_DI_IECP_CMD_PARAMS& VeboxDiIecpCmdParams,
3122 VPHAL_VEBOX_SURFACE_STATE_CMD_PARAMS& VeboxSurfaceStateCmdParams,
3123 MHW_VEBOX_SURFACE_STATE_CMD_PARAMS& MhwVeboxSurfaceStateCmdParams,
3124 MHW_VEBOX_STATE_CMD_PARAMS& VeboxStateCmdParams,
3125 MHW_MI_FLUSH_DW_PARAMS& FlushDwParams,
3126 PRENDERHAL_GENERIC_PROLOG_PARAMS pGenericPrologParams)
3127 {
3128 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3129 MhwVeboxInterfaceG12 *pVeboxInterface = nullptr;
3130 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
3131
3132 MHW_RENDERHAL_CHK_NULL(pVeboxState);
3133 MHW_RENDERHAL_CHK_NULL(pVeboxState->m_pRenderHal);
3134 MHW_RENDERHAL_CHK_NULL(pVeboxState->m_pRenderHal->pMhwMiInterface);
3135 MHW_RENDERHAL_CHK_NULL(pVeboxState->m_pVeboxInterface);
3136
3137 pVeboxInterface = (MhwVeboxInterfaceG12*)pVeboxState->m_pVeboxInterface;
3138
3139 VPHAL_RENDER_CHK_STATUS(pVeboxInterface->setVeboxPrologCmd(m_pRenderHal->pMhwMiInterface, &CmdBuffer));
3140
3141 return VPHAL_VEBOX_STATE::VeboxRenderVeboxCmd(CmdBuffer,
3142 VeboxDiIecpCmdParams,
3143 VeboxSurfaceStateCmdParams,
3144 MhwVeboxSurfaceStateCmdParams,
3145 VeboxStateCmdParams,
3146 FlushDwParams,
3147 pGenericPrologParams);
3148
3149 finish:
3150 return eStatus;
3151 }
3152
3153 VphalSfcState* VPHAL_VEBOX_STATE_G12_BASE::CreateSfcState()
3154 {
3155 #if __VPHAL_SFC_SUPPORTED
3156 VphalSfcState *sfcState = MOS_New(VphalSfcStateG12, m_pOsInterface, m_pRenderHal, m_pSfcInterface);
3157 #else
3158 VphalSfcState *sfcState = nullptr;
3159 #endif
3160
3161 return sfcState;
3162 }
3163
3164 VPHAL_VEBOX_STATE_G12_BASE::VPHAL_VEBOX_STATE_G12_BASE(
3165 PMOS_INTERFACE pOsInterface,
3166 PMHW_VEBOX_INTERFACE pVeboxInterface,
3167 PMHW_SFC_INTERFACE pSfcInterface,
3168 PRENDERHAL_INTERFACE pRenderHal,
3169 PVPHAL_VEBOX_EXEC_STATE pVeboxExecState,
3170 PVPHAL_RNDR_PERF_DATA pPerfData,
3171 const VPHAL_DNDI_CACHE_CNTL &dndiCacheCntl,
3172 MOS_STATUS *peStatus) :
3173 VPHAL_VEBOX_STATE(pOsInterface, pVeboxInterface, pSfcInterface, pRenderHal, pVeboxExecState, pPerfData, dndiCacheCntl, peStatus)
3174 {
3175 // States
3176 pKernelParamTable = (PRENDERHAL_KERNEL_PARAM)g_Vebox_KernelParam_g12;
3177 iNumFFDISurfaces = 2; // PE on: 4 used. PE off: 2 used
3178
3179 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
3180 #if (IGFX_GEN12_TGLLP_SUPPORTED)
3181 m_hdr3DLutKernelBinary = (uint32_t *)IGVP3DLUT_GENERATION_G12_TGLLP;
3182 m_hdr3DLutKernelBinarySize = IGVP3DLUT_GENERATION_G12_TGLLP_SIZE;
3183 #else
3184 const unsigned int IGVP3DLUT_GENERATION_G12_TGLLP_1[] =
3185 {
3186 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3187 };
3188 m_hdr3DLutKernelBinary = (uint32_t *)IGVP3DLUT_GENERATION_G12_TGLLP_1;
3189 m_hdr3DLutKernelBinarySize = 216; //IGVP3DLUT_GENERATION_G12_TGLLP_SIZE
3190 #endif
3191 #endif
3192 }
3193
3194 MOS_STATUS VPHAL_VEBOX_STATE_G12_BASE::Initialize(
3195 const VphalSettings *pSettings,
3196 Kdll_State *pKernelDllState)
3197 {
3198 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3199 PVPHAL_VEBOX_STATE_G12_BASE pVeboxState = this;
3200 bool enableMMC = false;
3201
3202 VPHAL_VEBOX_STATE::Initialize(pSettings, pKernelDllState);
3203
3204 // Read user feature key for MMC enable
3205 #if (LINUX) && (!WDDM_LINUX)
3206 enableMMC = !MEDIA_IS_WA(pVeboxState->m_pWaTable, WaDisableVPMmc); // enable MMC by default
3207 #else
3208 enableMMC = true;
3209 #endif
3210 if (m_userSettingPtr != nullptr)
3211 {
3212 ReadUserSetting(
3213 m_userSettingPtr,
3214 enableMMC,
3215 __VPHAL_ENABLE_MMC,
3216 MediaUserSetting::Group::Device,
3217 enableMMC,
3218 true);
3219 }
3220 // Set Vebox MMC enable
3221 pVeboxState->bEnableMMC = enableMMC && MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrE2ECompression);
3222
3223 // Set SFC MMC enable
3224 if (MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrSFCPipe) &&
3225 m_sfcPipeState)
3226 {
3227 m_sfcPipeState->SetSfcOutputMmcStatus(enableMMC && MEDIA_IS_SKU(pVeboxState->m_pSkuTable, FtrE2ECompression));
3228 }
3229
3230 return eStatus;
3231 }