1 /*==============================================================================
2 Copyright(c) 2017 Intel Corporation
3
4 Permission is hereby granted, free of charge, to any person obtaining a
5 copy of this software and associated documentation files(the "Software"),
6 to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 and / or sell copies of the Software, and to permit persons to whom the
9 Software is furnished to do so, subject to the following conditions:
10
11 The above copyright notice and this permission notice shall be included
12 in all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 OTHER DEALINGS IN THE SOFTWARE.
21 ============================================================================*/
22
23
24 #include "Internal/Common/GmmLibInc.h"
25
26 /////////////////////////////////////////////////////////////////////////////////////
27 /// Copies parameters or sets flags based on info sent by the client.
28 ///
29 /// @param[in] CreateParams: Flags which specify what sort of resource to create
30 /// @return false if encountered invalid param. true otherwise.
31 /////////////////////////////////////////////////////////////////////////////////////
CopyClientParams(GMM_RESCREATE_PARAMS & CreateParams)32 bool GmmLib::GmmResourceInfoCommon::CopyClientParams(GMM_RESCREATE_PARAMS &CreateParams)
33 {
34 uint32_t BitsPerPixel;
35 uint8_t Optimize64KBTile = 0;
36
37 if((CreateParams.Format > GMM_FORMAT_INVALID) &&
38 (CreateParams.Format < GMM_RESOURCE_FORMATS))
39 {
40 BitsPerPixel = GetGmmLibContext()->GetPlatformInfo().FormatTable[CreateParams.Format].Element.BitsPer;
41 }
42 else
43 {
44 GMM_ASSERTDPF(0, "Format Error");
45 return false;
46 }
47 {
48 // Promote tiling options if caller does not provide any.
49 // X/Y/W/L are tiling formats, and Yf/Ys are modifiers to the internal
50 // ordering for Y and L macro-formats.
51 if((CreateParams.Flags.Info.Linear +
52 CreateParams.Flags.Info.TiledW +
53 CreateParams.Flags.Info.TiledX +
54 CreateParams.Flags.Info.TiledY) == 0)
55 {
56 if(CreateParams.Type == RESOURCE_1D ||
57 CreateParams.Type == RESOURCE_BUFFER ||
58 CreateParams.Type == RESOURCE_SCRATCH ||
59 CreateParams.Flags.Info.ExistingSysMem)
60 {
61 CreateParams.Flags.Info.Linear = true;
62 }
63
64 if(GetGmmLibContext()->GetSkuTable().FtrTileY)
65 {
66
67 CreateParams.Flags.Info.TiledYs |= CreateParams.Flags.Info.StdSwizzle || CreateParams.Flags.Gpu.TiledResource;
68
69 // Propose L+Y by default.
70 CreateParams.Flags.Info.Linear = true;
71 CreateParams.Flags.Info.TiledY = true;
72
73 // Pre-Gen11 Planar
74 if(GmmIsPlanar(CreateParams.Format) && (GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform) < IGFX_GEN11_CORE))
75 {
76 CreateParams.Flags.Info.TiledX = true;
77 }
78 }
79 //Auto-tiling selection if not Linear already
80 else if(CreateParams.Flags.Info.Linear == 0)
81 {
82 // Xe_HP onwards.
83 if((CreateParams.Flags.Info.TiledYs +
84 CreateParams.Flags.Info.TiledYf +
85 CreateParams.Flags.Info.Tile4 +
86 CreateParams.Flags.Info.Tile64) == 0)
87 {
88 GMM_ASSERTDPF(!CreateParams.Flags.Info.StdSwizzle, "StdSwizzle not supported on current platform");
89
90 if(!GetGmmLibContext()->GetSkuTable().FtrForceTile4) // FtrForceTile4 should never be set by default, used for debug purpose only
91 {
92 // Default Tiling is set to Tile64 on FtrTileY disabled platforms
93 uint8_t IsYUVSurface = GmmIsPlanar(CreateParams.Format) ||
94 (GmmIsYUVPacked(CreateParams.Format));
95
96 //YCRCB* formats
97 uint8_t IsYCrCbSurface = ((CreateParams.Format == GMM_FORMAT_YCRCB_NORMAL) ||
98 (CreateParams.Format == GMM_FORMAT_YCRCB_SWAPUV) ||
99 (CreateParams.Format == GMM_FORMAT_YCRCB_SWAPUVY) || (CreateParams.Format == GMM_FORMAT_YCRCB_SWAPY));
100
101 CreateParams.Flags.Info.Tile4 = ((!GMM_IS_SUPPORTED_BPP_ON_TILE_64_YF_YS(BitsPerPixel)) || // 24,48,96 bpps are not supported on Tile64, Tile4 is bpp independent
102 ((CreateParams.Type == RESOURCE_3D) && (CreateParams.Flags.Gpu.Depth || CreateParams.Flags.Gpu.SeparateStencil)) ||
103 ((!GetGmmLibContext()->GetSkuTable().FtrDisplayDisabled) &&
104 (CreateParams.Flags.Gpu.FlipChain || CreateParams.Flags.Gpu.Overlay)
105 ) ||
106 IsYUVSurface || IsYCrCbSurface);
107
108 CreateParams.Flags.Info.Tile64 = !CreateParams.Flags.Info.Tile4;
109 // Optimize only when GMM makes tiling decision on behalf of UMD clients.
110 // Defering the memory calculations until GMM_TEXTURE_INFO is available.
111 if(CreateParams.Flags.Info.Tile64)
112 {
113 Optimize64KBTile = 1;
114 }
115 }
116 else
117 {
118 CreateParams.Flags.Info.Tile64 = (CreateParams.MSAA.NumSamples > 1) || CreateParams.Flags.Gpu.TiledResource; // Colour & Depth/Stencil(IMS) MSAA should use Tile64
119 CreateParams.Flags.Info.Tile4 = !CreateParams.Flags.Info.Tile64;
120 }
121 }
122 else if((CreateParams.Flags.Info.TiledYs +
123 CreateParams.Flags.Info.TiledYf) > 0)
124 {
125 GMM_ASSERTDPF(0, "Tile Yf/Ys not supported on given platform");
126
127 // Overrides the flags.
128 if(GetGmmLibContext()->GetSkuTable().FtrForceTile4)// FtrForceTile4 should never be set by default, used for debug purpose only.
129 {
130 CreateParams.Flags.Info.Tile64 = CreateParams.Flags.Info.TiledYs ||
131 (CreateParams.MSAA.NumSamples > 1) || CreateParams.Flags.Gpu.TiledResource; // Colour & Depth/Stencil(IMS) MSAA should use Tile64
132
133 CreateParams.Flags.Info.Tile4 = !CreateParams.Flags.Info.Tile64;
134 CreateParams.Flags.Info.TiledYf = 0;
135 CreateParams.Flags.Info.TiledYs = 0;
136 }
137 }
138 }
139 }
140 //Convert non linear & non-tiledX tiling selection by client to proper tiling.
141 else if(CreateParams.Flags.Info.Linear + CreateParams.Flags.Info.TiledX == 0)
142 {
143 if(!GetGmmLibContext()->GetSkuTable().FtrTileY)
144 {
145 __GMM_ASSERT(!(CreateParams.Flags.Info.TiledYs ||
146 CreateParams.Flags.Info.TiledYf ||
147 CreateParams.Flags.Info.TiledY));
148
149 // On Xe_HP onwards translate UMD's TileY/TileYs request to Tile4/Tile64 respectively
150 // Exclude TileX, Linear from override
151 if((GetGmmLibContext()->GetSkuTable().FtrForceTile4) && (CreateParams.Flags.Info.TiledYs || CreateParams.Flags.Info.TiledY))
152 {
153 CreateParams.Flags.Info.Tile64 =
154 CreateParams.Flags.Info.TiledYs ||
155 (CreateParams.MSAA.NumSamples > 1) || CreateParams.Flags.Gpu.TiledResource;
156
157 CreateParams.Flags.Info.Tile4 = !CreateParams.Flags.Info.Tile64;
158
159 CreateParams.Flags.Info.TiledY = 0;
160 CreateParams.Flags.Info.TiledYs = 0;
161 CreateParams.Flags.Info.TiledW = 0;
162 CreateParams.Flags.Info.TiledYf = 0;
163 }
164
165 // Displayable surfaces cannot be Tiled4/64.
166 __GMM_ASSERT(!GetGmmLibContext()->GetSkuTable().FtrDisplayYTiling);
167
168 //override displayable surfaces to TileX
169 if(GetGmmLibContext()->GetSkuTable().FtrDisplayXTiling)
170 {
171 if(CreateParams.Flags.Gpu.FlipChain || CreateParams.Flags.Gpu.Overlay ||
172 CreateParams.Flags.Gpu.Presentable)
173 {
174 CreateParams.Flags.Info.TiledX = 1;
175 CreateParams.Flags.Info.TiledY = 0;
176 CreateParams.Flags.Info.Tile4 = 0;
177 CreateParams.Flags.Info.Tile64 = 0;
178 }
179 }
180 }
181 }
182
183 //ExistingSysMem allocations must be Linear
184 __GMM_ASSERT(!CreateParams.Flags.Info.ExistingSysMem ||
185 CreateParams.Flags.Info.Linear);
186 }
187
188 if(GetGmmLibContext()->GetSkuTable().FtrMultiTileArch)
189 {
190 // For Naive apps, UMD does not populate multi tile arch params.
191 // Gmm will populate them based on the kmd assigned tile to the umd process
192 if(!CreateParams.MultiTileArch.Enable)
193 {
194 uint32_t GpuTile = 0;
195 __GMM_ASSERT(CreateParams.MultiTileArch.GpuVaMappingSet == 0);
196 __GMM_ASSERT(CreateParams.MultiTileArch.LocalMemEligibilitySet == 0);
197 __GMM_ASSERT(CreateParams.MultiTileArch.LocalMemPreferredSet == 0);
198
199 __GMM_ASSERT(GetGmmLibContext()->GetSkuTable().FtrAssignedGpuTile < 4);
200
201 #if !__GMM_KMD__
202 GpuTile = GetGmmLibContext()->GetSkuTable().FtrAssignedGpuTile;
203 CreateParams.MultiTileArch.GpuVaMappingSet = __BIT(GpuTile);
204 #else
205 GpuTile = 0;
206 CreateParams.MultiTileArch.GpuVaMappingSet = GetGmmLibContext()->GetGtSysInfo()->MultiTileArchInfo.TileMask;
207 #endif
208
209 CreateParams.MultiTileArch.Enable = true;
210
211 if(!CreateParams.Flags.Info.NonLocalOnly)
212 {
213 CreateParams.MultiTileArch.LocalMemEligibilitySet = __BIT(GpuTile);
214 CreateParams.MultiTileArch.LocalMemPreferredSet = __BIT(GpuTile);
215 }
216 }
217 }
218
219 Surf.Type = CreateParams.Type;
220 Surf.Format = CreateParams.Format;
221 Surf.BaseWidth = CreateParams.BaseWidth64;
222 Surf.BaseHeight = CreateParams.BaseHeight;
223 Surf.Depth = CreateParams.Depth;
224 Surf.MaxLod = CreateParams.MaxLod;
225 Surf.ArraySize = CreateParams.ArraySize;
226 Surf.Flags = CreateParams.Flags;
227 Surf.MSAA = CreateParams.MSAA;
228 Surf.Alignment.BaseAlignment = CreateParams.BaseAlignment;
229 Surf.CachePolicy.Usage = CreateParams.Usage;
230 Surf.MSAA.NumSamples = GFX_MAX(Surf.MSAA.NumSamples, 1);
231 Surf.MaximumRenamingListLength = CreateParams.MaximumRenamingListLength;
232 Surf.OverridePitch = CreateParams.OverridePitch;
233 Surf.CpTag = CreateParams.CpTag;
234
235 Surf.Flags.Info.__PreWddm2SVM =
236 Surf.Flags.Info.SVM &&
237 !(GetGmmLibContext()->GetSkuTable().FtrWddm2GpuMmu ||
238 GetGmmLibContext()->GetSkuTable().FtrWddm2Svm);
239
240 #if !__GMM_KMD__ && LHDM
241 if(GetGmmLibContext()->GetWaTable().WaLLCCachingUnsupported)
242 {
243 Surf.Flags.Info.GttMapType = (CreateParams.Flags.Info.Cacheable) ?
244 GMM_GTT_CACHETYPE_VLV_SNOOPED :
245 GMM_GTT_CACHETYPE_UNCACHED;
246 }
247
248 if(GetGmmLibContext()->GetSkuTable().FtrCameraCaptureCaching == false &&
249 CreateParams.Flags.Gpu.CameraCapture)
250 {
251 Surf.Flags.Info.Cacheable = 0;
252 }
253 Surf.Flags.Wa.ForceStdAllocAlign = 0;
254 #endif
255
256 #if(_DEBUG || _RELEASE_INTERNAL)
257 Surf.Platform = GetGmmLibContext()->GetPlatformInfo().Platform;
258 #endif
259
260 Surf.BitsPerPixel = BitsPerPixel;
261
262 // Get pTextureCalc after surface evaluation
263 GMM_TEXTURE_CALC *pTextureCalc = GMM_OVERRIDE_TEXTURE_CALC(&Surf, GetGmmLibContext());
264
265 GetGmmLibContext()->GetPlatformInfoObj()->SetCCSFlag(this->GetResFlags());
266
267 // Moderate down displayable flags if input parameters are not conducive.
268 // Reject non displayable tiling modes
269 if(Surf.Flags.Gpu.FlipChain || Surf.Flags.Gpu.Overlay)
270 {
271 if(Surf.Flags.Info.TiledY && !GetGmmLibContext()->GetSkuTable().FtrDisplayYTiling)
272 {
273 if(Surf.Flags.Gpu.FlipChainPreferred)
274 {
275 Surf.Flags.Gpu.Overlay = 0;
276 Surf.Flags.Gpu.FlipChain = 0;
277 }
278 else
279 {
280 GMM_ASSERTDPF(0, "Y-Tiling mode not displayable");
281 //return false;
282 }
283 }
284 }
285
286 // Memory optimization for 64KB tiled Surface.
287 if (!GetGmmLibContext()->GetSkuTable().FtrTileY)
288 {
289 if ((GetGmmLibContext()->GetSkuTable().FtrTile64Optimization) && Optimize64KBTile)
290 {
291 if ((GetGmmLibContext()->GetWaTable().Wa_14020040029) && (Surf.Flags.Gpu.Depth))
292 {
293 // if SW uses Tile4 merely to reduce surface size for Depth buffers,
294 // then use Tile64 instead
295 GMM_SET_64KB_TILE(Surf.Flags, 1, GetGmmLibContext());
296 GMM_SET_4KB_TILE(Surf.Flags, 0, GetGmmLibContext());
297
298 //Also update CreateParams, if client reuses the modified struct, it'd see final tile-selection by Gmm.
299 //Gmm's auto-tile-selection & tile-mode for size-optimization doesn't work for explicit tile-selection
300 GMM_SET_64KB_TILE(CreateParams.Flags, 1, GetGmmLibContext());
301 GMM_SET_4KB_TILE(CreateParams.Flags, 0, GetGmmLibContext());
302 }
303 else
304 {
305 if (pTextureCalc->SurfaceRequires64KBTileOptimization(&Surf))
306 {
307 GMM_SET_64KB_TILE(Surf.Flags, 0, GetGmmLibContext());
308 GMM_SET_4KB_TILE(Surf.Flags, 1, GetGmmLibContext());
309
310 //Also update CreateParams, if client reuses the modified struct, it'd see final tile-selection by Gmm.
311 //Gmm's auto-tile-selection & tile-mode for size-optimization doesn't work for explicit tile-selection
312 GMM_SET_64KB_TILE(CreateParams.Flags, 0, GetGmmLibContext());
313 GMM_SET_4KB_TILE(CreateParams.Flags, 1, GetGmmLibContext());
314 }
315 }
316 }
317 }
318
319 // Convert Any Pseudo Creation Params to Actual...
320 if(Surf.Flags.Gpu.UnifiedAuxSurface)
321 {
322 AuxSurf = Surf;
323
324 if(Surf.Flags.Gpu.Depth && Surf.Flags.Gpu.CCS) //Depth + HiZ+CCS
325 {
326 //GMM_ASSERTDPF(Surf.Flags.Gpu.HiZ, "Lossless Z compression supported when Depth+HiZ+CCS is unified");
327 AuxSecSurf = Surf;
328 AuxSecSurf.Type = GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS ? RESOURCE_INVALID : AuxSecSurf.Type;
329 Surf.Flags.Gpu.HiZ = 0; //Its depth buffer, so clear HiZ
330 AuxSecSurf.Flags.Gpu.HiZ = 0;
331 AuxSurf.Flags.Gpu.IndirectClearColor = 0; //Clear Depth flags from HiZ, contained with separate/legacy HiZ when Depth isn't compressible.
332 AuxSurf.Flags.Gpu.CCS = 0;
333 AuxSurf.Type = (AuxSurf.Flags.Gpu.HiZ) ? AuxSurf.Type : RESOURCE_INVALID;
334 AuxSurf.Flags.Info.RenderCompressed = AuxSurf.Flags.Info.MediaCompressed = 0;
335 AuxSurf.Flags.Info.NotCompressed = 1;
336 }
337 else if(Surf.Flags.Gpu.Depth && Surf.Flags.Gpu.HiZ && !Surf.Flags.Gpu.CCS) // Depth + HiZ only, CCS is disabled
338 {
339 // main surface is depth, AuxSurf is HiZ
340 Surf.Flags.Gpu.HiZ = 0; //depth buffer, clear HiZ
341 AuxSurf.Flags.Gpu.IndirectClearColor = 0; //Clear fastClear from HiZ
342 }
343 else if(Surf.Flags.Gpu.SeparateStencil && Surf.Flags.Gpu.CCS) //Stencil compression
344 {
345 AuxSurf.Flags.Gpu.SeparateStencil = 0;
346 Surf.Flags.Gpu.CCS = 0;
347 if(GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&Surf))
348 {
349 return false;
350 }
351 Surf.Flags.Gpu.CCS = 1;
352 AuxSurf.Type = GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS ? RESOURCE_INVALID : AuxSurf.Type;
353 }
354 else if(Surf.MSAA.NumSamples > 1 && Surf.Flags.Gpu.CCS) //MSAA+MCS+CCS
355 {
356 GMM_ASSERTDPF(Surf.Flags.Gpu.MCS, "Lossless MSAA supported when MSAA+MCS+CCS is unified");
357 AuxSecSurf = Surf;
358 AuxSecSurf.Type = GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS ? RESOURCE_INVALID : AuxSecSurf.Type;
359 AuxSecSurf.Flags.Gpu.MCS = 0;
360 AuxSurf.Flags.Gpu.CCS = 0;
361 AuxSurf.Flags.Info.RenderCompressed = AuxSurf.Flags.Info.MediaCompressed = 0;
362 AuxSurf.Flags.Info.NotCompressed = 1;
363 }
364 else if(Surf.Flags.Gpu.CCS)
365 {
366 AuxSurf.Type = (GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS && !Surf.Flags.Gpu.ProceduralTexture) ? RESOURCE_INVALID : AuxSurf.Type;
367 }
368
369 if(AuxSurf.Type != RESOURCE_INVALID &&
370 GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&AuxSurf))
371 {
372 return false;
373 }
374 if(AuxSecSurf.Type != RESOURCE_INVALID &&
375 GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&AuxSecSurf))
376 {
377 return false;
378 }
379 }
380 else
381 {
382 if(GMM_SUCCESS != pTextureCalc->PreProcessTexSpecialCases(&Surf))
383 {
384 return false;
385 }
386 }
387
388 RotateInfo = CreateParams.RotateInfo;
389
390 if(GetGmmLibContext()->GetSkuTable().FtrMultiTileArch)
391 {
392 MultiTileArch = CreateParams.MultiTileArch;
393 }
394
395 // For Xe2 RenderCompressed and MediaCompressed to be unset
396 if (GetGmmLibContext()->GetSkuTable().FtrXe2Compression)
397 {
398 //Deny compression
399 Surf.Flags.Info.RenderCompressed = 0;
400 Surf.Flags.Info.MediaCompressed = 0;
401 }
402 return true;
403 }
404
405
406 /////////////////////////////////////////////////////////////////////////////////////
407 /// Validates the parameters passed in by clients to make sure they do not
408 /// conflict or ask for unsupporting combinations/features.
409 ///
410 /// @return 1 is validation passed. 0 otherwise.
411 /////////////////////////////////////////////////////////////////////////////////////
ValidateParams()412 uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::ValidateParams()
413 {
414 __GMM_BUFFER_TYPE Restrictions = {0};
415 const __GMM_PLATFORM_RESOURCE *pPlatformResource = NULL;
416 GMM_TEXTURE_CALC * pTextureCalc = NULL;
417 bool AllowMaxWidthViolations = false;
418 bool AllowMaxHeightViolations = false;
419 uint8_t Status = 0;
420
421 GMM_DPF_ENTER;
422
423 __GMM_ASSERTPTR(GetGmmLibContext(), 0);
424
425 #if(defined(__GMM_KMD__) && (_DEBUG || _RELEASE_INTERNAL))
426 //KMD Debug and Release Internal Drivers only
427 //if GMM_TEXTURE_INFO's platform type != native platform
428 //then initialize the OverridePlatformInfo.
429
430 //If GMM_TEXTURE_INFO's platform type == IGFX_UNKNOWN_CORE then it means that UMD driver is
431 //in "Release" version and passes all zeros in Surf.Platform
432 if(GFX_GET_CURRENT_RENDERCORE(Surf.Platform) == IGFX_UNKNOWN_CORE)
433 {
434 Surf.Platform = GetGmmLibContext()->GetPlatformInfo().Platform;
435 // If this is a unified surface then make sure the AUX surface has the same platform info
436 if(Surf.Flags.Gpu.UnifiedAuxSurface)
437 {
438 AuxSurf.Platform = Surf.Platform;
439 AuxSecSurf.Platform = Surf.Platform;
440 }
441 }
442
443 if(GetGmmLibContext()->GetPlatformInfoObj() != NULL &&
444 (GFX_GET_CURRENT_RENDERCORE(Surf.Platform) !=
445 GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform)) &&
446 (GetGmmLibContext()->GetOverridePlatformInfoObj() == NULL ||
447 (GFX_GET_CURRENT_RENDERCORE(Surf.Platform) !=
448 GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetOverridePlatformInfo().Platform))))
449 {
450 //Ensure override is a future platform.
451 __GMM_ASSERT(GFX_GET_CURRENT_RENDERCORE(Surf.Platform) >
452 GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform));
453
454 GetGmmLibContext()->SetOverridePlatformInfoObj(GetGmmLibContext()->CreatePlatformInfo(Surf.Platform, true));
455
456 if(GetGmmLibContext()->GetOverrideTextureCalc())
457 {
458 delete(GetGmmLibContext()->GetOverrideTextureCalc());
459 GetGmmLibContext()->SetOverrideTextureCalc(NULL);
460 }
461
462 GetGmmLibContext()->SetOverrideTextureCalc(GetGmmLibContext()->CreateTextureCalc(Surf.Platform, true));
463
464 }
465 #endif
466
467 pPlatformResource = GMM_OVERRIDE_PLATFORM_INFO(&Surf, GetGmmLibContext());
468 pTextureCalc = GMM_OVERRIDE_TEXTURE_CALC(&Surf, GetGmmLibContext());
469
470 if (!pTextureCalc)
471 {
472 GMM_ASSERTDPF(0, "Texture Calculation pointer is NULL.");
473 goto ERROR_CASE;
474 }
475
476 __GMM_ASSERT(!(
477 Surf.Flags.Gpu.Query &&
478 !Surf.Flags.Info.Cacheable)); // Why query not set as cacheable? If not cacheable, what keeps from stolen memory (because STORE_DWORD/PIPE_CONTROL/etc. targets can't be in stolen)?
479
480 if(Surf.Flags.Gpu.HiZ)
481 {
482 // HiZ checked in PreProcessTexSpecialCases before legal HZ_Width/Height expansion.
483 AllowMaxWidthViolations = true;
484 AllowMaxHeightViolations = true;
485 }
486
487 // check bpp
488 if(((Surf.BitsPerPixel < 8) || (Surf.BitsPerPixel % GMM_BITS(8))) &&
489 !(Surf.BitsPerPixel == 1))
490 {
491 GMM_ASSERTDPF(0, "Invalid BitsPerPixel!");
492 goto ERROR_CASE;
493 }
494
495 // Check at least one tile pref set.
496 // Yf/Ys checked explicitly here, require one of Y or Linear depending on resource type (e.g 1D-->Linear)
497 // that TODO: could be automatically promoted.
498 if((Surf.Flags.Info.Linear == 0) &&
499 (Surf.Flags.Info.TiledX == 0) &&
500 (Surf.Flags.Info.TiledW == 0) &&
501 (Surf.Flags.Info.TiledYf == 0) &&
502 !GMM_IS_4KB_TILE(Surf.Flags) && !GMM_IS_64KB_TILE(Surf.Flags))
503 {
504 GMM_ASSERTDPF(0, "No Tile or Linear preference specified!");
505 goto ERROR_CASE;
506 }
507
508 if(Surf.Flags.Info.Tile64 || Surf.Flags.Info.TiledYf || Surf.Flags.Info.TiledYs)
509 {
510 if(!GMM_IS_SUPPORTED_BPP_ON_TILE_64_YF_YS(Surf.BitsPerPixel))
511 {
512 GMM_ASSERTDPF(0, "BPP not supported on selected Tile format!");
513 goto ERROR_CASE;
514 }
515 }
516
517 if(!__CanSupportStdTiling(Surf, GetGmmLibContext()))
518 {
519 GMM_ASSERTDPF(0, "Invalid TileYf/TileYs usage!");
520 goto ERROR_CASE;
521 }
522
523 if(Surf.TileMode < TILE_NONE || Surf.TileMode >= GMM_TILE_MODES)
524 {
525 GMM_ASSERTDPF(0, "Invalid TileMode usage!");
526 goto ERROR_CASE;
527 }
528
529 if(!((Surf.Format > GMM_FORMAT_INVALID) &&
530 (Surf.Format < GMM_RESOURCE_FORMATS)))
531 {
532 GMM_ASSERTDPF(0, "Invalid Resource Format!");
533 goto ERROR_CASE;
534 }
535
536 // Check resource format is supported on running platform
537 if(IsPresentableformat() == false)
538 {
539 GMM_ASSERTDPF(0, "Bad Format!");
540 goto ERROR_CASE;
541 }
542
543 if((Surf.Type == RESOURCE_PRIMARY) &&
544 !Surf.Flags.Gpu.FlipChain)
545 {
546 GMM_ASSERTDPF(0, "Primary does not have FlipChain flag set.");
547 goto ERROR_CASE;
548 }
549
550 if(Surf.Flags.Gpu.Overlay &&
551 Surf.Flags.Gpu.FlipChain)
552 {
553 GMM_ASSERTDPF(0, "Overlay and FlipChain flags set. S3D logic may fail.");
554 goto ERROR_CASE;
555 }
556
557 // Displayable surfaces must remain Tile4
558 if(((!GetGmmLibContext()->GetSkuTable().FtrDisplayDisabled) &&
559 (Surf.Flags.Gpu.Overlay || Surf.Flags.Gpu.FlipChain)) &&
560 (!(Surf.Flags.Info.Linear || Surf.Flags.Info.TiledX || GMM_IS_4KB_TILE(Surf.Flags))))
561 {
562 GMM_ASSERTDPF(0, "Unsupported tiling format for displayable resource.");
563 goto ERROR_CASE;
564 }
565
566 if(GetGmmLibContext()->GetSkuTable().FtrLocalMemory)
567 {
568 GMM_ASSERTDPF(((Surf.Flags.Info.NonLocalOnly && Surf.Flags.Info.LocalOnly) == 0),
569 "Incorrect segment preference, cannot be both local and system memory.");
570
571 // Before overriding the flags predetermine if compression request is deniable or not.
572 if(!Surf.Flags.Info.LocalOnly &&
573 (!(Surf.Flags.Gpu.Overlay || Surf.Flags.Gpu.FlipChain)) &&
574 !(Surf.Flags.Info.HardwareProtected))
575 {
576 Surf.Flags.Wa.DeniableLocalOnlyForCompression = 1;
577 }
578
579 if(Surf.Flags.Gpu.Overlay ||
580 Surf.Flags.Gpu.FlipChain)
581 {
582 if(Surf.Flags.Info.NonLocalOnly)
583 {
584 GMM_ASSERTDPF(0, "Overlay and FlipChain cannot be in system memory.");
585 goto ERROR_CASE;
586 }
587 Surf.Flags.Info.LocalOnly = 1;
588 Surf.Flags.Info.NonLocalOnly = 0;
589 }
590 if(GetGmmLibContext()->GetSkuTable().FtrFlatPhysCCS &&
591 !GetGmmLibContext()->GetSkuTable().FtrXe2Compression &&
592 (Surf.Flags.Info.RenderCompressed ||
593 Surf.Flags.Info.MediaCompressed))
594 {
595 if(Surf.Flags.Info.NonLocalOnly)
596 {
597 GMM_ASSERTDPF(0, "Compressible surfaces cannot be in system memory.");
598 goto ERROR_CASE;
599 }
600 Surf.Flags.Info.LocalOnly = 1;
601 Surf.Flags.Info.NonLocalOnly = 0;
602 }
603
604 if(!Surf.Flags.Info.NotLockable &&
605 Surf.Flags.Info.Shared)
606 {
607 if(Surf.Flags.Info.LocalOnly)
608 {
609 GMM_ASSERTDPF(0, "Lockable Shared cannot be in local memory.");
610 goto ERROR_CASE;
611 }
612 Surf.Flags.Info.LocalOnly = 0;
613 Surf.Flags.Info.NonLocalOnly = 1;
614 }
615
616 if(Surf.Flags.Gpu.CameraCapture)
617 {
618 if(Surf.Flags.Info.LocalOnly)
619 {
620 GMM_ASSERTDPF(0, "CameraCapture cannot be in local memory.");
621 }
622 Surf.Flags.Info.LocalOnly = 0;
623 Surf.Flags.Info.NonLocalOnly = 1;
624 }
625
626 if(GetGmmLibContext()->GetWaTable().Wa64kbMappingAt2mbGranularity &&
627 (!GetGmmLibContext()->GetSkuTable().FtrLocalMemoryAllows4KB) &&
628 !Surf.Flags.Info.NonLocalOnly)
629 {
630 Surf.Flags.Info.LocalOnly = true;
631
632 }
633 }
634 else
635 {
636 Surf.Flags.Info.LocalOnly = false; //Zero out on iGPU
637 if (GetGmmLibContext()->GetSkuTable().FtrXe2Compression && Surf.Flags.Info.XAdapter)
638 {
639 Surf.Flags.Info.NotCompressed = 1; // disable compression for XAdapter resources on iGPU,
640 Surf.Flags.Gpu.CCS = 0;
641 Surf.Flags.Gpu.UnifiedAuxSurface = 0;
642 Surf.Flags.Gpu.IndirectClearColor = 0;
643 Surf.Flags.Gpu.MCS = 0;
644 }
645 }
646 if (GetGmmLibContext()->GetSkuTable().FtrXe2Compression)
647 {
648 if (Surf.Flags.Info.TiledX)
649 {
650 if (!(Surf.Flags.Gpu.FlipChain || Surf.Flags.Gpu.Overlay))
651 {
652 GMM_ASSERTDPF(0, "TiledX request for non displayable");
653 }
654 Surf.Flags.Info.NotCompressed = 1; // disable compression for TileX resources
655 }
656
657 if ((Surf.Flags.Gpu.FlipChain || Surf.Flags.Gpu.Overlay) && !Surf.Flags.Info.Tile4)
658 {
659 Surf.Flags.Info.NotCompressed = 1; //Disable compression if displayable are not tile4
660 }
661 }
662
663 if((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) < IGFX_GEN8_CORE) &&
664 Surf.Flags.Info.TiledW)
665 {
666 GMM_ASSERTDPF(0, "Flag not supported on this platform.");
667 goto ERROR_CASE;
668 }
669
670 if((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) > IGFX_GEN11_CORE) &&
671 Surf.Flags.Info.TiledW)
672 {
673 GMM_ASSERTDPF(0, "Flag not supported on this platform.");
674 goto ERROR_CASE;
675 }
676
677 if((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) < IGFX_GEN9_CORE) &&
678 #if(_DEBUG || _RELEASE_INTERNAL)
679 !GetGmmLibContext()->GetWaTable().WaDisregardPlatformChecks &&
680 #endif
681 Surf.Flags.Gpu.MMC)
682 {
683 GMM_ASSERTDPF(0, "Flag not supported on this platform.");
684 goto ERROR_CASE;
685 }
686
687 //For Media Memory Compression --
688 if((Status = GetGmmLibContext()->GetPlatformInfoObj()->ValidateMMC(Surf)) == 0)
689 {
690 GMM_ASSERTDPF(0, "Invalid flag or array size!");
691 goto ERROR_CASE;
692 }
693
694 if(!GetGmmLibContext()->GetSkuTable().FtrTileY)
695 {
696 if(Surf.Flags.Gpu.TiledResource &&
697 ((Surf.Flags.Info.Linear && !(Surf.Type == RESOURCE_BUFFER)) || Surf.Flags.Info.TiledYs ||
698 Surf.Flags.Info.TiledYf || Surf.Flags.Info.TiledY))
699 {
700 GMM_ASSERTDPF(0, "Invalid Tile for TiledResource!");
701 goto ERROR_CASE;
702 }
703 if(GMM_IS_64KB_TILE(Surf.Flags) &&
704 (Surf.MSAA.NumSamples > 1) &&
705 (Surf.MaxLod != 0))
706 {
707 GMM_ASSERTDPF(0, "Mipped MSAA not supported for Tile64!");
708 goto ERROR_CASE;
709 }
710 // Tile4 does not support MSAA.
711 if(GMM_IS_4KB_TILE(Surf.Flags) &&
712 (Surf.MSAA.NumSamples > 1))
713 {
714 GMM_ASSERTDPF(0, "No MSAA support for Tile4!");
715 goto ERROR_CASE;
716 }
717 }
718
719 __GMM_ASSERT(!(GetGmmLibContext()->GetSkuTable().FtrTileY &&
720 (Surf.Flags.Info.Tile4 || Surf.Flags.Info.Tile64)));
721
722 //GMM asserts that ExistingSysMem allocation (whose malloc is outside GmmLib) are either
723 //SVM Buffer, Index Buffer, Vertex Buffers, Render Target, Texture
724 if(Surf.Flags.Info.ExistingSysMem &&
725 !Surf.ExistingSysMem.IsGmmAllocated &&
726 !Surf.ExistingSysMem.IsPageAligned)
727 {
728 if(!(Surf.Flags.Gpu.RenderTarget ||
729 Surf.Flags.Gpu.Vertex ||
730 Surf.Flags.Gpu.Index ||
731 Surf.Flags.Gpu.Texture ||
732 Surf.Flags.Info.Linear ||
733 Surf.Flags.Info.SVM))
734 {
735 GMM_ASSERTDPF(0, "Flag not supported by ExistingSysMem alloc!");
736 goto ERROR_CASE;
737 }
738
739 if(Surf.Type == RESOURCE_3D ||
740 Surf.Type == RESOURCE_CUBE ||
741 Surf.MaxLod ||
742 GmmIsYUVPlanar(Surf.Format))
743 {
744 GMM_ASSERTDPF(0, "Invalid ExistingSysMem resource Type/Format");
745 goto ERROR_CASE;
746 }
747 }
748
749 pTextureCalc->GetResRestrictions(&Surf, Restrictions);
750
751 // Check array size to make sure it meets HW limits
752 if((Surf.ArraySize > Restrictions.MaxArraySize) &&
753 ((RESOURCE_1D == Surf.Type) ||
754 (RESOURCE_2D == Surf.Type) ||
755 (RESOURCE_CUBE == Surf.Type)))
756 {
757 GMM_ASSERTDPF(0, "Invalid array size!");
758 goto ERROR_CASE;
759 }
760
761 // Check dimensions to make sure it meets HW max limits
762 if(((Surf.BaseHeight > Restrictions.MaxHeight) && !AllowMaxHeightViolations) ||
763 ((Surf.BaseWidth > Restrictions.MaxWidth) && !AllowMaxWidthViolations) ||
764 (Surf.Depth > Restrictions.MaxDepth)) // Any reason why MaxDepth != 1 for Tex2D
765 {
766 GMM_ASSERTDPF(0, "Invalid Dimension. Greater than max!");
767 goto ERROR_CASE;
768 }
769
770 // Check width to make sure it meets Yx requirements
771 if(((Surf.Format == GMM_FORMAT_Y8_UNORM_VA) && (Surf.BaseWidth % 4)) ||
772 ((Surf.Format == GMM_FORMAT_Y16_UNORM) && (Surf.BaseWidth % 2)) ||
773 ((Surf.Format == GMM_FORMAT_Y1_UNORM) && (Surf.BaseWidth % 32)))
774 {
775 GMM_ASSERTDPF(0, "Invalid width!");
776 goto ERROR_CASE;
777 }
778
779 // Check dimensions to make sure it meets HW min limits
780 if((Surf.BaseHeight < Restrictions.MinHeight) ||
781 (Surf.BaseWidth < Restrictions.MinWidth) ||
782 (Surf.Depth < Restrictions.MinDepth))
783 {
784 GMM_ASSERTDPF(0, "Invalid Dimension. Less than min!");
785 goto ERROR_CASE;
786 }
787
788 // check mip map
789 if(Surf.MaxLod > pPlatformResource->MaxLod)
790 {
791 GMM_ASSERTDPF(0, "Invalid mip map chain specified!");
792 goto ERROR_CASE;
793 }
794
795 // MIPs are not supported for tiled Yf/Ys planar surfaces
796 if((Surf.MaxLod) &&
797 GmmIsPlanar(Surf.Format) &&
798 (Surf.Flags.Info.TiledYf || GMM_IS_64KB_TILE(Surf.Flags)))
799 {
800 GMM_ASSERTDPF(0, "Invalid mip map chain specified!");
801 goto ERROR_CASE;
802 }
803
804 // check depth buffer tilings
805 if((Surf.Flags.Gpu.Depth == 1) &&
806 (Surf.Flags.Info.TiledX == 1))
807 {
808 GMM_ASSERTDPF(0, "Invalid Tiling for Depth Buffer!");
809 goto ERROR_CASE;
810 }
811
812 #if DBG
813 // Check if stencil buffer gpu flag is set w/ other flags
814 if(Surf.Flags.Gpu.SeparateStencil == 1)
815 {
816 GMM_RESOURCE_FLAG OnlySeparateStencilGpuFlag;
817
818 memset(&OnlySeparateStencilGpuFlag.Gpu, 0, sizeof(OnlySeparateStencilGpuFlag.Gpu));
819 OnlySeparateStencilGpuFlag.Gpu.SeparateStencil = 1;
820
821 if(memcmp(&Surf.Flags.Gpu, &OnlySeparateStencilGpuFlag.Gpu, sizeof(OnlySeparateStencilGpuFlag.Gpu)))
822 {
823 GMM_ASSERTDPF(0,
824 "Should not set w/ other flags b/c vertical alignment is "
825 "unique for separate stencil and incompatible w/ other "
826 "usages such as render target.");
827 goto ERROR_CASE;
828 }
829 }
830 #endif
831
832 // MSAA Restrictions
833 if((Surf.MSAA.NumSamples > 1) &&
834 !( //--- Legitimate MSAA Case ------------------------------------------
835 (Surf.Type == RESOURCE_2D) &&
836 (Surf.Flags.Gpu.Depth ||
837 Surf.Flags.Gpu.HiZ ||
838 Surf.Flags.Gpu.RenderTarget ||
839 Surf.Flags.Gpu.SeparateStencil) &&
840 // Single-LOD (pre-SKL)...
841 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN9_CORE) ||
842 (Surf.MaxLod == 0)) &&
843 // TileYF cannot be MSAA'ed (pre-Gen10)...
844 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN10_CORE) ||
845 !Surf.Flags.Info.TiledYf) &&
846 // Tile64 MSAA (Xe_HP)
847 (GetGmmLibContext()->GetSkuTable().FtrTileY ||
848 !GMM_IS_64KB_TILE(Surf.Flags) ||
849 (Surf.MaxLod == 0)) &&
850 // Tile4 does not support MSAA
851 (GetGmmLibContext()->GetSkuTable().FtrTileY ||
852 !GMM_IS_4KB_TILE(Surf.Flags)) &&
853 // Non-Compressed/YUV...
854 !GmmIsCompressed(GetGmmLibContext(), Surf.Format) &&
855 !GmmIsYUVPacked(Surf.Format) &&
856 !GmmIsPlanar(Surf.Format) &&
857 // Supported Sample Count for Platform...
858 (((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN7_CORE) &&
859 ((Surf.MSAA.NumSamples == 4) || (Surf.MSAA.NumSamples == 8))) ||
860 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN8_CORE) &&
861 ((Surf.MSAA.NumSamples == 2))) ||
862 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN9_CORE) &&
863 ((Surf.MSAA.NumSamples == 16))))))
864 {
865 GMM_ASSERTDPF(0, "Invalid MSAA usage!");
866 goto ERROR_CASE;
867 }
868
869 // CCS Restrictions
870 if(Surf.Flags.Gpu.CCS)
871 {
872 if((Status = GetGmmLibContext()->GetPlatformInfoObj()->ValidateCCS(Surf)) == 0)
873 {
874 GMM_ASSERTDPF(0, "Invalid CCS usage!");
875 goto ERROR_CASE;
876 }
877
878 if(Surf.Flags.Info.RenderCompressed && Surf.Flags.Info.MediaCompressed)
879 {
880 GMM_ASSERTDPF(0, "Invalid CCS usage - can't be both RC and MC!");
881 goto ERROR_CASE;
882 }
883 }
884
885 // UnifiedAuxSurface Restrictions
886 if((Status = GetGmmLibContext()->GetPlatformInfoObj()->ValidateUnifiedAuxSurface(Surf)) == 0)
887 {
888 GMM_ASSERTDPF(0, "Invalid UnifiedAuxSurface usage!");
889 goto ERROR_CASE;
890 }
891
892 // IndirectClearColor Restrictions
893 if((Surf.Flags.Gpu.IndirectClearColor) &&
894 !( //--- Legitimate IndirectClearColor Case ------------------------------------------
895 (((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN9_CORE) && Surf.Flags.Gpu.UnifiedAuxSurface) ||
896 ((GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) > IGFX_GEN11_CORE) && (Surf.Flags.Gpu.HiZ || Surf.Flags.Gpu.SeparateStencil)))))
897
898 {
899 GMM_ASSERTDPF(0, "Invalid IndirectClearColor usage!");
900 goto ERROR_CASE;
901 }
902
903 // CornerTexelMode Restrictions
904 if(Surf.Flags.Info.CornerTexelMode &&
905 (!( //--- Legitimate CornerTexelMode Case -------------------------------------------
906 (GFX_GET_CURRENT_RENDERCORE(pPlatformResource->Platform) >= IGFX_GEN11_CORE) &&
907 (!GmmIsPlanar(Surf.Format)) &&
908 (!Surf.Flags.Info.StdSwizzle))))
909 {
910 GMM_ASSERTDPF(0, "Flag.Info.CornerTexelMode not supported on this platform.");
911 goto ERROR_CASE;
912 }
913
914 //MultiTileArch params
915 if(GetGmmLibContext()->GetSkuTable().FtrMultiTileArch)
916 {
917 /*
918 MultiTileArch validation criteria
919 - MultiTileArch.Enable must be set.
920 - NonLocalOnly alloc must have LocalEligibilitySet and LocalPreferenceSet both zero
921 - LocalOnly alloc must have non-zero LocalEligibilitySet
922 - GpuVaMappingSet/LocalEligibilitySet must be subset of GtSysInfo.TileMask
923 - PreferredSet must be subset of EligibilitySet or zero
924 */
925 if(!(
926 // Legitimate cases
927 MultiTileArch.Enable &&
928 (Surf.Flags.Info.NonLocalOnly || MultiTileArch.LocalMemEligibilitySet) &&
929 ((MultiTileArch.GpuVaMappingSet & GetGmmLibContext()->GetGtSysInfo()->MultiTileArchInfo.TileMask) == MultiTileArch.GpuVaMappingSet) &&
930 ((MultiTileArch.LocalMemEligibilitySet & GetGmmLibContext()->GetGtSysInfo()->MultiTileArchInfo.TileMask) == MultiTileArch.LocalMemEligibilitySet) &&
931 ((MultiTileArch.LocalMemEligibilitySet & MultiTileArch.LocalMemPreferredSet) == MultiTileArch.LocalMemPreferredSet)))
932 {
933 GMM_ASSERTDPF(0, "Invalid MultiTileArch allocation params");
934 goto ERROR_CASE;
935 }
936 }
937
938 // check 2D, 3D & Cubemap dimensions
939 switch(Surf.Type)
940 {
941 case RESOURCE_1D:
942 case RESOURCE_2D:
943 case RESOURCE_3D:
944 {
945 if(!Surf.BaseWidth || !Surf.BaseHeight)
946 {
947 GMM_ASSERTDPF(0, "Width or Height is 0!");
948 goto ERROR_CASE;
949 }
950 break;
951 }
952 case RESOURCE_CUBE:
953 {
954 if(!Surf.BaseWidth || !Surf.BaseHeight)
955 {
956 GMM_ASSERTDPF(0, "Cubemap Dimensions invalid!");
957 goto ERROR_CASE;
958 }
959 if(Surf.BaseWidth != Surf.BaseHeight)
960 {
961 GMM_ASSERTDPF(0, "Cubemap Dimensions invalid (width != Height)!");
962 goto ERROR_CASE;
963 }
964 break;
965 }
966 case RESOURCE_SCRATCH:
967 case RESOURCE_BUFFER:
968 {
969 if(Surf.BaseHeight != 1)
970 {
971 GMM_ASSERTDPF(0, "Linear surface height not 1!");
972 goto ERROR_CASE;
973 }
974 break;
975 }
976 default:
977 if (!Surf.BaseWidth || !Surf.BaseHeight)
978 {
979 GMM_ASSERTDPF(0, "Width or Height is 0!");
980 goto ERROR_CASE;
981 }
982 break;
983 }
984
985 GMM_DPF_EXIT;
986 return 1;
987
988 ERROR_CASE:
989 __GMM_ASSERT(0);
990 return 0;
991 }
992
993 //=============================================================================
994 //
995 // Function: GetDisplayCompressionSupport
996 //
997 // Desc: Returns true if display hw supports lossless render/media decompression
998 // else returns false.
999 // Umds can call it to decide if full resolve is required
1000 //
1001 // Parameters:
1002 // See function arguments.
1003 //
1004 // Returns:
1005 // uint8_t
1006 //-----------------------------------------------------------------------------
GetDisplayCompressionSupport()1007 uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetDisplayCompressionSupport()
1008 {
1009 uint8_t ComprSupported = 0;
1010 GMM_RESOURCE_FORMAT Format = Surf.Format;
1011
1012 if(Surf.Flags.Gpu.UnifiedAuxSurface)
1013 {
1014 bool IsSupportedRGB64_16_16_16_16 = false;
1015 bool IsSupportedRGB32_8_8_8_8 = false;
1016 bool IsSupportedRGB32_2_10_10_10 = false;
1017 bool IsSupportedMediaFormats = false;
1018
1019 switch(Format) //RGB64 16:16 : 16 : 16 FP16
1020 {
1021 case GMM_FORMAT_R16G16B16A16_FLOAT:
1022 case GMM_FORMAT_R16G16B16X16_FLOAT:
1023 IsSupportedRGB64_16_16_16_16 = true;
1024 default:
1025 break;
1026 }
1027
1028 switch(Format) //RGB32 8 : 8 : 8 : 8
1029 {
1030 case GMM_FORMAT_B8G8R8A8_UNORM:
1031 case GMM_FORMAT_R8G8B8A8_UNORM:
1032 case GMM_FORMAT_B8G8R8X8_UNORM:
1033 case GMM_FORMAT_R8G8B8X8_UNORM:
1034 case GMM_FORMAT_R8G8B8A8_UNORM_SRGB:
1035 case GMM_FORMAT_B8X8_UNORM_G8R8_SNORM:
1036 case GMM_FORMAT_X8B8_UNORM_G8R8_SNORM:
1037 case GMM_FORMAT_A8X8_UNORM_G8R8_SNORM:
1038 case GMM_FORMAT_B8G8R8A8_UNORM_SRGB:
1039 case GMM_FORMAT_B8G8R8X8_UNORM_SRGB:
1040 case GMM_FORMAT_R8G8B8A8_SINT:
1041 case GMM_FORMAT_R8G8B8A8_SNORM:
1042 case GMM_FORMAT_R8G8B8A8_SSCALED:
1043 case GMM_FORMAT_R8G8B8A8_UINT:
1044 case GMM_FORMAT_R8G8B8A8_USCALED:
1045 case GMM_FORMAT_R8G8B8X8_UNORM_SRGB:
1046 IsSupportedRGB32_8_8_8_8 = true;
1047 default:
1048 break;
1049 }
1050
1051 switch(Format) //RGB32 2 : 10 : 10 : 10
1052 {
1053 case GMM_FORMAT_B10G10R10X2_UNORM:
1054 case GMM_FORMAT_R10G10B10A2_UNORM:
1055 case GMM_FORMAT_B10G10R10A2_UNORM:
1056 case GMM_FORMAT_B10G10R10A2_SINT:
1057 case GMM_FORMAT_B10G10R10A2_SNORM:
1058 case GMM_FORMAT_B10G10R10A2_SSCALED:
1059 case GMM_FORMAT_B10G10R10A2_UINT:
1060 case GMM_FORMAT_B10G10R10A2_UNORM_SRGB:
1061 case GMM_FORMAT_B10G10R10A2_USCALED:
1062 case GMM_FORMAT_R10G10B10_FLOAT_A2_UNORM:
1063 case GMM_FORMAT_R10G10B10_SNORM_A2_UNORM:
1064 case GMM_FORMAT_R10G10B10A2_SINT:
1065 case GMM_FORMAT_R10G10B10A2_SNORM:
1066 case GMM_FORMAT_R10G10B10A2_SSCALED:
1067 case GMM_FORMAT_R10G10B10A2_UINT:
1068 case GMM_FORMAT_R10G10B10A2_UNORM_SRGB:
1069 case GMM_FORMAT_R10G10B10A2_USCALED:
1070 case GMM_FORMAT_R10G10B10X2_USCALED:
1071 case GMM_FORMAT_R10G10B10_XR_BIAS_A2_UNORM:
1072 IsSupportedRGB32_2_10_10_10 = true;
1073 default:
1074 break;
1075 }
1076
1077 switch(Format)
1078 {
1079 case GMM_FORMAT_YUY2: //YUV422 8 bpc
1080 case GMM_FORMAT_NV12: //YUV420 - NV12
1081 case GMM_FORMAT_P010: //YUV420 - P0xx
1082 case GMM_FORMAT_P016:
1083 case GMM_FORMAT_Y210: //YUV422 - Y210, Y212, Y216
1084 case GMM_FORMAT_Y216:
1085 case GMM_FORMAT_Y410: //YUV444 - Y410
1086 case GMM_FORMAT_Y416:
1087 IsSupportedMediaFormats = true; //YUV444 - Y412, Y416
1088 default:
1089 break;
1090 }
1091
1092 //Check fmt is display decompressible
1093 ComprSupported = GetGmmLibContext()->GetPlatformInfoObj()->CheckFmtDisplayDecompressible(Surf, IsSupportedRGB64_16_16_16_16,
1094 IsSupportedRGB32_8_8_8_8, IsSupportedRGB32_2_10_10_10,
1095 IsSupportedMediaFormats);
1096 }
1097
1098 return ComprSupported;
1099 }
1100
1101 //=============================================================================
1102 //
1103 // Function: GetDisplayFastClearSupport
1104 //
1105 // Desc: Returns 1 if display hw supports fast clear else returns 0.
1106 // Umds can call it to decide if FC resolve is required
1107 //
1108 // Parameters:
1109 // See function arguments.
1110 //
1111 // Returns:
1112 // uint8_t
1113 //-----------------------------------------------------------------------------
GetDisplayFastClearSupport()1114 uint8_t GMM_STDCALL GmmLib::GmmResourceInfoCommon::GetDisplayFastClearSupport()
1115 {
1116 uint8_t FCSupported = 0;
1117
1118 if(GFX_GET_CURRENT_RENDERCORE(GetGmmLibContext()->GetPlatformInfo().Platform) >= IGFX_GEN11_CORE)
1119 {
1120 FCSupported = GetDisplayCompressionSupport() && !GmmIsPlanar(Surf.Format);
1121 FCSupported &= Surf.Flags.Gpu.IndirectClearColor;
1122 }
1123
1124 return FCSupported;
1125 }
1126