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