1 /*
2 * Copyright © 2017 Advanced Micro Devices, Inc.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
15 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16 * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
17 * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20 * USE OR OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
24 * of the Software.
25 */
26
27 /**
28 ************************************************************************************************************************
29 * @file addrlib2.cpp
30 * @brief Contains the implementation for the AddrLib2 base class.
31 ************************************************************************************************************************
32 */
33
34 #include "addrinterface.h"
35 #include "addrlib2.h"
36 #include "addrcommon.h"
37
38 namespace Addr
39 {
40 namespace V2
41 {
42
43 ////////////////////////////////////////////////////////////////////////////////////////////////////
44 // Static Const Member
45 ////////////////////////////////////////////////////////////////////////////////////////////////////
46
47 const Dim2d Lib::Block256_2d[] = {{16, 16}, {16, 8}, {8, 8}, {8, 4}, {4, 4}};
48
49 const Dim3d Lib::Block1K_3d[] = {{16, 8, 8}, {8, 8, 8}, {8, 8, 4}, {8, 4, 4}, {4, 4, 4}};
50
51 ////////////////////////////////////////////////////////////////////////////////////////////////////
52 // Constructor/Destructor
53 ////////////////////////////////////////////////////////////////////////////////////////////////////
54
55 /**
56 ************************************************************************************************************************
57 * Lib::Lib
58 *
59 * @brief
60 * Constructor for the Addr::V2::Lib class
61 *
62 ************************************************************************************************************************
63 */
Lib()64 Lib::Lib()
65 :
66 Addr::Lib()
67 {
68 }
69
70 /**
71 ************************************************************************************************************************
72 * Lib::Lib
73 *
74 * @brief
75 * Constructor for the AddrLib2 class with hClient as parameter
76 *
77 ************************************************************************************************************************
78 */
Lib(const Client * pClient)79 Lib::Lib(const Client* pClient)
80 :
81 Addr::Lib(pClient)
82 {
83 }
84
85 /**
86 ************************************************************************************************************************
87 * Lib::~Lib
88 *
89 * @brief
90 * Destructor for the AddrLib2 class
91 *
92 ************************************************************************************************************************
93 */
~Lib()94 Lib::~Lib()
95 {
96 }
97
98 /**
99 ************************************************************************************************************************
100 * Lib::GetLib
101 *
102 * @brief
103 * Get Addr::V2::Lib pointer
104 *
105 * @return
106 * An Addr::V2::Lib class pointer
107 ************************************************************************************************************************
108 */
GetLib(ADDR_HANDLE hLib)109 Lib* Lib::GetLib(
110 ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
111 {
112 Addr::Lib* pAddrLib = Addr::Lib::GetLib(hLib);
113 if ((pAddrLib != NULL) &&
114 (pAddrLib->GetChipFamily() <= ADDR_CHIP_FAMILY_VI))
115 {
116 // only valid and GFX9+ AISC can use AddrLib2 function.
117 ADDR_ASSERT_ALWAYS();
118 hLib = NULL;
119 }
120 return static_cast<Lib*>(hLib);
121 }
122
123
124 ////////////////////////////////////////////////////////////////////////////////////////////////////
125 // Surface Methods
126 ////////////////////////////////////////////////////////////////////////////////////////////////////
127
128
129 /**
130 ************************************************************************************************************************
131 * Lib::ComputeSurfaceInfo
132 *
133 * @brief
134 * Interface function stub of AddrComputeSurfaceInfo.
135 *
136 * @return
137 * ADDR_E_RETURNCODE
138 ************************************************************************************************************************
139 */
ComputeSurfaceInfo(const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR2_COMPUTE_SURFACE_INFO_OUTPUT * pOut) const140 ADDR_E_RETURNCODE Lib::ComputeSurfaceInfo(
141 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
142 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
143 ) const
144 {
145 ADDR_E_RETURNCODE returnCode = ADDR_OK;
146
147 if (GetFillSizeFieldsFlags() == TRUE)
148 {
149 if ((pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_INFO_INPUT)) ||
150 (pOut->size != sizeof(ADDR2_COMPUTE_SURFACE_INFO_OUTPUT)))
151 {
152 returnCode = ADDR_PARAMSIZEMISMATCH;
153 }
154 }
155
156 // Adjust coming parameters.
157 ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = *pIn;
158 localIn.width = Max(pIn->width, 1u);
159 localIn.height = Max(pIn->height, 1u);
160 localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
161 localIn.numSlices = Max(pIn->numSlices, 1u);
162 localIn.numSamples = Max(pIn->numSamples, 1u);
163 localIn.numFrags = (localIn.numFrags == 0) ? localIn.numSamples : pIn->numFrags;
164
165 UINT_32 expandX = 1;
166 UINT_32 expandY = 1;
167 ElemMode elemMode = ADDR_UNCOMPRESSED;
168
169 if (returnCode == ADDR_OK)
170 {
171 // Set format to INVALID will skip this conversion
172 if (localIn.format != ADDR_FMT_INVALID)
173 {
174 // Get compression/expansion factors and element mode which indicates compression/expansion
175 localIn.bpp = GetElemLib()->GetBitsPerPixel(localIn.format,
176 &elemMode,
177 &expandX,
178 &expandY);
179
180 // Special flag for 96 bit surface. 96 (or 48 if we support) bit surface's width is
181 // pre-multiplied by 3 and bpp is divided by 3. So pitch alignment for linear-
182 // aligned does not meet 64-pixel in real. We keep special handling in hwl since hw
183 // restrictions are different.
184 // Also Mip 1+ needs an element pitch of 32 bits so we do not need this workaround
185 // but we use this flag to skip RestoreSurfaceInfo below
186
187 if ((elemMode == ADDR_EXPANDED) && (expandX > 1))
188 {
189 ADDR_ASSERT(IsLinear(localIn.swizzleMode));
190 }
191
192 UINT_32 basePitch = 0;
193 GetElemLib()->AdjustSurfaceInfo(elemMode,
194 expandX,
195 expandY,
196 &localIn.bpp,
197 &basePitch,
198 &localIn.width,
199 &localIn.height);
200
201 // Overwrite these parameters if we have a valid format
202 }
203
204 if (localIn.bpp != 0)
205 {
206 localIn.width = Max(localIn.width, 1u);
207 localIn.height = Max(localIn.height, 1u);
208 }
209 else // Rule out some invalid parameters
210 {
211 ADDR_ASSERT_ALWAYS();
212
213 returnCode = ADDR_INVALIDPARAMS;
214 }
215 }
216
217 if (returnCode == ADDR_OK)
218 {
219 returnCode = ComputeSurfaceInfoSanityCheck(&localIn);
220 }
221
222 if (returnCode == ADDR_OK)
223 {
224 VerifyMipLevelInfo(pIn);
225
226 if (IsLinear(pIn->swizzleMode))
227 {
228 // linear mode
229 returnCode = ComputeSurfaceInfoLinear(&localIn, pOut);
230 }
231 else
232 {
233 // tiled mode
234 returnCode = ComputeSurfaceInfoTiled(&localIn, pOut);
235 }
236
237 if (returnCode == ADDR_OK)
238 {
239 pOut->bpp = localIn.bpp;
240 pOut->pixelPitch = pOut->pitch;
241 pOut->pixelHeight = pOut->height;
242 pOut->pixelMipChainPitch = pOut->mipChainPitch;
243 pOut->pixelMipChainHeight = pOut->mipChainHeight;
244 pOut->pixelBits = localIn.bpp;
245
246 if (localIn.format != ADDR_FMT_INVALID)
247 {
248 UINT_32 pixelBits = pOut->pixelBits;
249
250 GetElemLib()->RestoreSurfaceInfo(elemMode,
251 expandX,
252 expandY,
253 &pOut->pixelBits,
254 &pOut->pixelPitch,
255 &pOut->pixelHeight);
256
257 GetElemLib()->RestoreSurfaceInfo(elemMode,
258 expandX,
259 expandY,
260 &pixelBits,
261 &pOut->pixelMipChainPitch,
262 &pOut->pixelMipChainHeight);
263
264 if ((localIn.numMipLevels > 1) && (pOut->pMipInfo != NULL))
265 {
266 for (UINT_32 i = 0; i < localIn.numMipLevels; i++)
267 {
268 pOut->pMipInfo[i].pixelPitch = pOut->pMipInfo[i].pitch;
269 pOut->pMipInfo[i].pixelHeight = pOut->pMipInfo[i].height;
270
271 GetElemLib()->RestoreSurfaceInfo(elemMode,
272 expandX,
273 expandY,
274 &pixelBits,
275 &pOut->pMipInfo[i].pixelPitch,
276 &pOut->pMipInfo[i].pixelHeight);
277 }
278 }
279 }
280
281 if (localIn.flags.needEquation && (Log2(localIn.numFrags) == 0))
282 {
283 pOut->equationIndex = GetEquationIndex(&localIn, pOut);
284 }
285
286 if (localIn.flags.qbStereo)
287 {
288 if (pOut->pStereoInfo != NULL)
289 {
290 ComputeQbStereoInfo(pOut);
291 }
292 }
293 }
294 }
295
296 ADDR_ASSERT(pOut->surfSize != 0);
297
298 return returnCode;
299 }
300
301 /**
302 ************************************************************************************************************************
303 * Lib::ComputeSurfaceInfo
304 *
305 * @brief
306 * Interface function stub of AddrComputeSurfaceInfo.
307 *
308 * @return
309 * ADDR_E_RETURNCODE
310 ************************************************************************************************************************
311 */
ComputeSurfaceAddrFromCoord(const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut) const312 ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoord(
313 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
314 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
315 ) const
316 {
317 ADDR_E_RETURNCODE returnCode = ADDR_OK;
318
319 if (GetFillSizeFieldsFlags() == TRUE)
320 {
321 if ((pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT)) ||
322 (pOut->size != sizeof(ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT)))
323 {
324 returnCode = ADDR_PARAMSIZEMISMATCH;
325 }
326 }
327
328 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT localIn = *pIn;
329 localIn.unalignedWidth = Max(pIn->unalignedWidth, 1u);
330 localIn.unalignedHeight = Max(pIn->unalignedHeight, 1u);
331 localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
332 localIn.numSlices = Max(pIn->numSlices, 1u);
333 localIn.numSamples = Max(pIn->numSamples, 1u);
334 localIn.numFrags = Max(pIn->numFrags, 1u);
335
336 if ((localIn.bpp < 8) ||
337 (localIn.bpp > 128) ||
338 ((localIn.bpp % 8) != 0) ||
339 (localIn.sample >= localIn.numSamples) ||
340 (localIn.slice >= localIn.numSlices) ||
341 (localIn.mipId >= localIn.numMipLevels) ||
342 (IsTex3d(localIn.resourceType) &&
343 (Valid3DMipSliceIdConstraint(localIn.numSlices, localIn.mipId, localIn.slice) == FALSE)))
344 {
345 returnCode = ADDR_INVALIDPARAMS;
346 }
347
348 if (returnCode == ADDR_OK)
349 {
350 if (IsLinear(localIn.swizzleMode))
351 {
352 returnCode = ComputeSurfaceAddrFromCoordLinear(&localIn, pOut);
353 }
354 else
355 {
356 returnCode = ComputeSurfaceAddrFromCoordTiled(&localIn, pOut);
357 }
358
359 if (returnCode == ADDR_OK)
360 {
361 pOut->prtBlockIndex = static_cast<UINT_32>(pOut->addr / (64 * 1024));
362 }
363 }
364
365 return returnCode;
366 }
367
368 /**
369 ************************************************************************************************************************
370 * Lib::ComputeSurfaceCoordFromAddr
371 *
372 * @brief
373 * Interface function stub of ComputeSurfaceCoordFromAddr.
374 *
375 * @return
376 * ADDR_E_RETURNCODE
377 ************************************************************************************************************************
378 */
ComputeSurfaceCoordFromAddr(const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut) const379 ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddr(
380 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
381 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
382 ) const
383 {
384 ADDR_E_RETURNCODE returnCode = ADDR_OK;
385
386 if (GetFillSizeFieldsFlags() == TRUE)
387 {
388 if ((pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT)) ||
389 (pOut->size != sizeof(ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT)))
390 {
391 returnCode = ADDR_PARAMSIZEMISMATCH;
392 }
393 }
394
395 if ((pIn->bpp < 8) ||
396 (pIn->bpp > 128) ||
397 ((pIn->bpp % 8) != 0) ||
398 (pIn->bitPosition >= 8))
399 {
400 returnCode = ADDR_INVALIDPARAMS;
401 }
402
403 if (returnCode == ADDR_OK)
404 {
405 if (IsLinear(pIn->swizzleMode))
406 {
407 returnCode = ComputeSurfaceCoordFromAddrLinear(pIn, pOut);
408 }
409 else
410 {
411 returnCode = ComputeSurfaceCoordFromAddrTiled(pIn, pOut);
412 }
413 }
414
415 return returnCode;
416 }
417
418
419 ////////////////////////////////////////////////////////////////////////////////////////////////////
420 // CMASK/HTILE
421 ////////////////////////////////////////////////////////////////////////////////////////////////////
422
423 /**
424 ************************************************************************************************************************
425 * Lib::ComputeHtileInfo
426 *
427 * @brief
428 * Interface function stub of AddrComputeHtilenfo
429 *
430 * @return
431 * ADDR_E_RETURNCODE
432 ************************************************************************************************************************
433 */
ComputeHtileInfo(const ADDR2_COMPUTE_HTILE_INFO_INPUT * pIn,ADDR2_COMPUTE_HTILE_INFO_OUTPUT * pOut) const434 ADDR_E_RETURNCODE Lib::ComputeHtileInfo(
435 const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
436 ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut ///< [out] output structure
437 ) const
438 {
439 ADDR_E_RETURNCODE returnCode;
440
441 if ((GetFillSizeFieldsFlags() == TRUE) &&
442 ((pIn->size != sizeof(ADDR2_COMPUTE_HTILE_INFO_INPUT)) ||
443 (pOut->size != sizeof(ADDR2_COMPUTE_HTILE_INFO_OUTPUT))))
444 {
445 returnCode = ADDR_INVALIDPARAMS;
446 }
447 else
448 {
449 returnCode = HwlComputeHtileInfo(pIn, pOut);
450 }
451
452 return returnCode;
453 }
454
455 /**
456 ************************************************************************************************************************
457 * Lib::ComputeHtileAddrFromCoord
458 *
459 * @brief
460 * Interface function stub of AddrComputeHtileAddrFromCoord
461 *
462 * @return
463 * ADDR_E_RETURNCODE
464 ************************************************************************************************************************
465 */
ComputeHtileAddrFromCoord(const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT * pOut)466 ADDR_E_RETURNCODE Lib::ComputeHtileAddrFromCoord(
467 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
468 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
469 {
470 ADDR_E_RETURNCODE returnCode;
471
472 if ((GetFillSizeFieldsFlags() == TRUE) &&
473 ((pIn->size != sizeof(ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT)) ||
474 (pOut->size != sizeof(ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT))))
475 {
476 returnCode = ADDR_INVALIDPARAMS;
477 }
478 else
479 {
480 returnCode = HwlComputeHtileAddrFromCoord(pIn, pOut);
481 }
482
483 return returnCode;
484 }
485
486 /**
487 ************************************************************************************************************************
488 * Lib::ComputeHtileCoordFromAddr
489 *
490 * @brief
491 * Interface function stub of AddrComputeHtileCoordFromAddr
492 *
493 * @return
494 * ADDR_E_RETURNCODE
495 ************************************************************************************************************************
496 */
ComputeHtileCoordFromAddr(const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT * pOut)497 ADDR_E_RETURNCODE Lib::ComputeHtileCoordFromAddr(
498 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
499 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] output structure
500 {
501 ADDR_E_RETURNCODE returnCode;
502
503 if ((GetFillSizeFieldsFlags() == TRUE) &&
504 ((pIn->size != sizeof(ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT)) ||
505 (pOut->size != sizeof(ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT))))
506 {
507 returnCode = ADDR_INVALIDPARAMS;
508 }
509 else
510 {
511 returnCode = HwlComputeHtileCoordFromAddr(pIn, pOut);
512 }
513
514 return returnCode;
515 }
516
517 /**
518 ************************************************************************************************************************
519 * Lib::ComputeCmaskInfo
520 *
521 * @brief
522 * Interface function stub of AddrComputeCmaskInfo
523 *
524 * @return
525 * ADDR_E_RETURNCODE
526 ************************************************************************************************************************
527 */
ComputeCmaskInfo(const ADDR2_COMPUTE_CMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_CMASK_INFO_OUTPUT * pOut) const528 ADDR_E_RETURNCODE Lib::ComputeCmaskInfo(
529 const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
530 ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut ///< [out] output structure
531 ) const
532 {
533 ADDR_E_RETURNCODE returnCode;
534
535 if ((GetFillSizeFieldsFlags() == TRUE) &&
536 ((pIn->size != sizeof(ADDR2_COMPUTE_CMASK_INFO_INPUT)) ||
537 (pOut->size != sizeof(ADDR2_COMPUTE_CMASK_INFO_OUTPUT))))
538 {
539 returnCode = ADDR_INVALIDPARAMS;
540 }
541 else if (pIn->cMaskFlags.linear)
542 {
543 returnCode = ADDR_INVALIDPARAMS;
544 }
545 else
546 {
547 returnCode = HwlComputeCmaskInfo(pIn, pOut);
548 }
549
550 return returnCode;
551 }
552
553 /**
554 ************************************************************************************************************************
555 * Lib::ComputeCmaskAddrFromCoord
556 *
557 * @brief
558 * Interface function stub of AddrComputeCmaskAddrFromCoord
559 *
560 * @return
561 * ADDR_E_RETURNCODE
562 ************************************************************************************************************************
563 */
ComputeCmaskAddrFromCoord(const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT * pOut)564 ADDR_E_RETURNCODE Lib::ComputeCmaskAddrFromCoord(
565 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
566 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
567 {
568 ADDR_E_RETURNCODE returnCode;
569
570 if ((GetFillSizeFieldsFlags() == TRUE) &&
571 ((pIn->size != sizeof(ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT)) ||
572 (pOut->size != sizeof(ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT))))
573 {
574 returnCode = ADDR_INVALIDPARAMS;
575 }
576 else
577 {
578 returnCode = HwlComputeCmaskAddrFromCoord(pIn, pOut);
579 }
580
581 return returnCode;
582 }
583
584 /**
585 ************************************************************************************************************************
586 * Lib::ComputeCmaskCoordFromAddr
587 *
588 * @brief
589 * Interface function stub of AddrComputeCmaskCoordFromAddr
590 *
591 * @return
592 * ADDR_E_RETURNCODE
593 ************************************************************************************************************************
594 */
ComputeCmaskCoordFromAddr(const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT * pOut) const595 ADDR_E_RETURNCODE Lib::ComputeCmaskCoordFromAddr(
596 const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
597 ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
598 ) const
599 {
600 ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
601
602 ADDR_NOT_IMPLEMENTED();
603
604 return returnCode;
605 }
606
607 /**
608 ************************************************************************************************************************
609 * Lib::ComputeFmaskInfo
610 *
611 * @brief
612 * Interface function stub of ComputeFmaskInfo.
613 *
614 * @return
615 * ADDR_E_RETURNCODE
616 ************************************************************************************************************************
617 */
ComputeFmaskInfo(const ADDR2_COMPUTE_FMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_FMASK_INFO_OUTPUT * pOut)618 ADDR_E_RETURNCODE Lib::ComputeFmaskInfo(
619 const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
620 ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut ///< [out] output structure
621 )
622 {
623 ADDR_E_RETURNCODE returnCode;
624
625 BOOL_32 valid = (IsZOrderSwizzle(pIn->swizzleMode) == TRUE) &&
626 ((pIn->numSamples > 0) || (pIn->numFrags > 0));
627
628 if (GetFillSizeFieldsFlags())
629 {
630 if ((pIn->size != sizeof(ADDR2_COMPUTE_FMASK_INFO_INPUT)) ||
631 (pOut->size != sizeof(ADDR2_COMPUTE_FMASK_INFO_OUTPUT)))
632 {
633 valid = FALSE;
634 }
635 }
636
637 if (valid == FALSE)
638 {
639 returnCode = ADDR_INVALIDPARAMS;
640 }
641 else
642 {
643 ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
644 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
645
646 localIn.size = sizeof(ADDR2_COMPUTE_SURFACE_INFO_INPUT);
647 localOut.size = sizeof(ADDR2_COMPUTE_SURFACE_INFO_OUTPUT);
648
649 localIn.swizzleMode = pIn->swizzleMode;
650 localIn.numSlices = Max(pIn->numSlices, 1u);
651 localIn.width = Max(pIn->unalignedWidth, 1u);
652 localIn.height = Max(pIn->unalignedHeight, 1u);
653 localIn.bpp = GetFmaskBpp(pIn->numSamples, pIn->numFrags);
654 localIn.flags.fmask = 1;
655 localIn.numFrags = 1;
656 localIn.numSamples = 1;
657 localIn.resourceType = ADDR_RSRC_TEX_2D;
658
659 if (localIn.bpp == 8)
660 {
661 localIn.format = ADDR_FMT_8;
662 }
663 else if (localIn.bpp == 16)
664 {
665 localIn.format = ADDR_FMT_16;
666 }
667 else if (localIn.bpp == 32)
668 {
669 localIn.format = ADDR_FMT_32;
670 }
671 else
672 {
673 localIn.format = ADDR_FMT_32_32;
674 }
675
676 returnCode = ComputeSurfaceInfo(&localIn, &localOut);
677
678 if (returnCode == ADDR_OK)
679 {
680 pOut->pitch = localOut.pitch;
681 pOut->height = localOut.height;
682 pOut->baseAlign = localOut.baseAlign;
683 pOut->numSlices = localOut.numSlices;
684 pOut->fmaskBytes = static_cast<UINT_32>(localOut.surfSize);
685 pOut->sliceSize = static_cast<UINT_32>(localOut.sliceSize);
686 pOut->bpp = localIn.bpp;
687 pOut->numSamples = 1;
688 }
689 }
690
691 return returnCode;
692 }
693
694 /**
695 ************************************************************************************************************************
696 * Lib::ComputeFmaskAddrFromCoord
697 *
698 * @brief
699 * Interface function stub of ComputeFmaskAddrFromCoord.
700 *
701 * @return
702 * ADDR_E_RETURNCODE
703 ************************************************************************************************************************
704 */
ComputeFmaskAddrFromCoord(const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT * pOut) const705 ADDR_E_RETURNCODE Lib::ComputeFmaskAddrFromCoord(
706 const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
707 ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
708 ) const
709 {
710 ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
711
712 ADDR_NOT_IMPLEMENTED();
713
714 return returnCode;
715 }
716
717 /**
718 ************************************************************************************************************************
719 * Lib::ComputeFmaskCoordFromAddr
720 *
721 * @brief
722 * Interface function stub of ComputeFmaskAddrFromCoord.
723 *
724 * @return
725 * ADDR_E_RETURNCODE
726 ************************************************************************************************************************
727 */
ComputeFmaskCoordFromAddr(const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT * pOut) const728 ADDR_E_RETURNCODE Lib::ComputeFmaskCoordFromAddr(
729 const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
730 ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
731 ) const
732 {
733 ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
734
735 ADDR_NOT_IMPLEMENTED();
736
737 return returnCode;
738 }
739
740 /**
741 ************************************************************************************************************************
742 * Lib::ComputeDccInfo
743 *
744 * @brief
745 * Interface function to compute DCC key info
746 *
747 * @return
748 * return code of HwlComputeDccInfo
749 ************************************************************************************************************************
750 */
ComputeDccInfo(const ADDR2_COMPUTE_DCCINFO_INPUT * pIn,ADDR2_COMPUTE_DCCINFO_OUTPUT * pOut) const751 ADDR_E_RETURNCODE Lib::ComputeDccInfo(
752 const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
753 ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut ///< [out] output structure
754 ) const
755 {
756 ADDR_E_RETURNCODE returnCode;
757
758 if ((GetFillSizeFieldsFlags() == TRUE) &&
759 ((pIn->size != sizeof(ADDR2_COMPUTE_DCCINFO_INPUT)) ||
760 (pOut->size != sizeof(ADDR2_COMPUTE_DCCINFO_OUTPUT))))
761 {
762 returnCode = ADDR_INVALIDPARAMS;
763 }
764 else
765 {
766 returnCode = HwlComputeDccInfo(pIn, pOut);
767 }
768
769 return returnCode;
770 }
771
772 /**
773 ************************************************************************************************************************
774 * Lib::ComputeDccAddrFromCoord
775 *
776 * @brief
777 * Interface function stub of ComputeDccAddrFromCoord
778 *
779 * @return
780 * ADDR_E_RETURNCODE
781 ************************************************************************************************************************
782 */
ComputeDccAddrFromCoord(const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT * pOut)783 ADDR_E_RETURNCODE Lib::ComputeDccAddrFromCoord(
784 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
785 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
786 {
787 ADDR_E_RETURNCODE returnCode;
788
789 if ((GetFillSizeFieldsFlags() == TRUE) &&
790 ((pIn->size != sizeof(ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT)) ||
791 (pOut->size != sizeof(ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT))))
792 {
793 returnCode = ADDR_INVALIDPARAMS;
794 }
795 else
796 {
797 returnCode = HwlComputeDccAddrFromCoord(pIn, pOut);
798 }
799
800 return returnCode;
801 }
802
803 /**
804 ************************************************************************************************************************
805 * Lib::ComputePipeBankXor
806 *
807 * @brief
808 * Interface function stub of Addr2ComputePipeBankXor.
809 *
810 * @return
811 * ADDR_E_RETURNCODE
812 ************************************************************************************************************************
813 */
ComputePipeBankXor(const ADDR2_COMPUTE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT * pOut)814 ADDR_E_RETURNCODE Lib::ComputePipeBankXor(
815 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
816 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut)
817 {
818 ADDR_E_RETURNCODE returnCode;
819
820 if ((GetFillSizeFieldsFlags() == TRUE) &&
821 ((pIn->size != sizeof(ADDR2_COMPUTE_PIPEBANKXOR_INPUT)) ||
822 (pOut->size != sizeof(ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT))))
823 {
824 returnCode = ADDR_INVALIDPARAMS;
825 }
826 else if (IsXor(pIn->swizzleMode) == FALSE)
827 {
828 returnCode = ADDR_NOTSUPPORTED;
829 }
830 else
831 {
832 returnCode = HwlComputePipeBankXor(pIn, pOut);
833 }
834
835 return returnCode;
836 }
837
838 /**
839 ************************************************************************************************************************
840 * Lib::ComputeSlicePipeBankXor
841 *
842 * @brief
843 * Interface function stub of Addr2ComputeSlicePipeBankXor.
844 *
845 * @return
846 * ADDR_E_RETURNCODE
847 ************************************************************************************************************************
848 */
ComputeSlicePipeBankXor(const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT * pOut)849 ADDR_E_RETURNCODE Lib::ComputeSlicePipeBankXor(
850 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
851 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut)
852 {
853 ADDR_E_RETURNCODE returnCode;
854
855 if ((GetFillSizeFieldsFlags() == TRUE) &&
856 ((pIn->size != sizeof(ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT)) ||
857 (pOut->size != sizeof(ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT))))
858 {
859 returnCode = ADDR_INVALIDPARAMS;
860 }
861 else if ((IsThin(pIn->resourceType, pIn->swizzleMode) == FALSE) ||
862 (IsNonPrtXor(pIn->swizzleMode) == FALSE) ||
863 (pIn->numSamples > 1))
864 {
865 returnCode = ADDR_NOTSUPPORTED;
866 }
867 else
868 {
869 returnCode = HwlComputeSlicePipeBankXor(pIn, pOut);
870 }
871
872 return returnCode;
873 }
874
875 /**
876 ************************************************************************************************************************
877 * Lib::ComputeSubResourceOffsetForSwizzlePattern
878 *
879 * @brief
880 * Interface function stub of Addr2ComputeSubResourceOffsetForSwizzlePattern.
881 *
882 * @return
883 * ADDR_E_RETURNCODE
884 ************************************************************************************************************************
885 */
ComputeSubResourceOffsetForSwizzlePattern(const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT * pIn,ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT * pOut)886 ADDR_E_RETURNCODE Lib::ComputeSubResourceOffsetForSwizzlePattern(
887 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
888 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut)
889 {
890 ADDR_E_RETURNCODE returnCode;
891
892 if ((GetFillSizeFieldsFlags() == TRUE) &&
893 ((pIn->size != sizeof(ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT)) ||
894 (pOut->size != sizeof(ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT))))
895 {
896 returnCode = ADDR_INVALIDPARAMS;
897 }
898 else
899 {
900 returnCode = HwlComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
901 }
902
903 return returnCode;
904 }
905
906 /**
907 ************************************************************************************************************************
908 * Lib::ExtractPipeBankXor
909 *
910 * @brief
911 * Internal function to extract bank and pipe xor bits from combined xor bits.
912 *
913 * @return
914 * ADDR_E_RETURNCODE
915 ************************************************************************************************************************
916 */
ExtractPipeBankXor(UINT_32 pipeBankXor,UINT_32 bankBits,UINT_32 pipeBits,UINT_32 * pBankX,UINT_32 * pPipeX)917 ADDR_E_RETURNCODE Lib::ExtractPipeBankXor(
918 UINT_32 pipeBankXor,
919 UINT_32 bankBits,
920 UINT_32 pipeBits,
921 UINT_32* pBankX,
922 UINT_32* pPipeX)
923 {
924 ADDR_E_RETURNCODE returnCode;
925
926 if (pipeBankXor < (1u << (pipeBits + bankBits)))
927 {
928 *pPipeX = pipeBankXor % (1 << pipeBits);
929 *pBankX = pipeBankXor >> pipeBits;
930 returnCode = ADDR_OK;
931 }
932 else
933 {
934 ADDR_ASSERT_ALWAYS();
935 returnCode = ADDR_INVALIDPARAMS;
936 }
937
938 return returnCode;
939 }
940
941 /**
942 ************************************************************************************************************************
943 * Lib::ComputeSurfaceInfoSanityCheck
944 *
945 * @brief
946 * Internal function to do basic sanity check before compute surface info
947 *
948 * @return
949 * ADDR_E_RETURNCODE
950 ************************************************************************************************************************
951 */
ComputeSurfaceInfoSanityCheck(const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn) const952 ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoSanityCheck(
953 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in] input structure
954 ) const
955 {
956 ADDR_E_RETURNCODE returnCode;
957
958 if ((GetFillSizeFieldsFlags() == TRUE) &&
959 (pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_INFO_INPUT)))
960 {
961 returnCode = ADDR_INVALIDPARAMS;
962 }
963 else
964 {
965 returnCode = HwlComputeSurfaceInfoSanityCheck(pIn);
966 }
967
968 return returnCode;
969 }
970
971 /**
972 ************************************************************************************************************************
973 * Lib::ApplyCustomizedPitchHeight
974 *
975 * @brief
976 * Helper function to override hw required row pitch/slice pitch by customrized one
977 *
978 * @return
979 * ADDR_E_RETURNCODE
980 ************************************************************************************************************************
981 */
ApplyCustomizedPitchHeight(const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn,UINT_32 elementBytes,UINT_32 pitchAlignInElement,UINT_32 * pPitch,UINT_32 * pHeight) const982 ADDR_E_RETURNCODE Lib::ApplyCustomizedPitchHeight(
983 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
984 UINT_32 elementBytes, ///< [in] element bytes per element
985 UINT_32 pitchAlignInElement, ///< [in] pitch alignment in element
986 UINT_32* pPitch, ///< [in/out] pitch
987 UINT_32* pHeight ///< [in/out] height
988 ) const
989 {
990 ADDR_E_RETURNCODE returnCode = ADDR_OK;
991
992 if (pIn->numMipLevels <= 1)
993 {
994 if (pIn->pitchInElement > 0)
995 {
996 if ((pIn->pitchInElement % pitchAlignInElement) != 0)
997 {
998 returnCode = ADDR_INVALIDPARAMS;
999 }
1000 else if (pIn->pitchInElement < (*pPitch))
1001 {
1002 returnCode = ADDR_INVALIDPARAMS;
1003 }
1004 else
1005 {
1006 *pPitch = pIn->pitchInElement;
1007 }
1008 }
1009
1010 if (returnCode == ADDR_OK)
1011 {
1012 if (pIn->sliceAlign > 0)
1013 {
1014 UINT_32 customizedHeight = pIn->sliceAlign / elementBytes / (*pPitch);
1015
1016 if (customizedHeight * elementBytes * (*pPitch) != pIn->sliceAlign)
1017 {
1018 returnCode = ADDR_INVALIDPARAMS;
1019 }
1020 else if ((pIn->numSlices > 1) && ((*pHeight) != customizedHeight))
1021 {
1022 returnCode = ADDR_INVALIDPARAMS;
1023 }
1024 else
1025 {
1026 *pHeight = customizedHeight;
1027 }
1028 }
1029 }
1030 }
1031
1032 return returnCode;
1033 }
1034
1035 /**
1036 ************************************************************************************************************************
1037 * Lib::ComputeSurfaceInfoLinear
1038 *
1039 * @brief
1040 * Internal function to calculate alignment for linear swizzle surface
1041 *
1042 * @return
1043 * ADDR_E_RETURNCODE
1044 ************************************************************************************************************************
1045 */
ComputeSurfaceInfoLinear(const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR2_COMPUTE_SURFACE_INFO_OUTPUT * pOut) const1046 ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoLinear(
1047 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
1048 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
1049 ) const
1050 {
1051 return HwlComputeSurfaceInfoLinear(pIn, pOut);
1052 }
1053
1054 /**
1055 ************************************************************************************************************************
1056 * Lib::ComputeSurfaceInfoTiled
1057 *
1058 * @brief
1059 * Internal function to calculate alignment for tiled swizzle surface
1060 *
1061 * @return
1062 * ADDR_E_RETURNCODE
1063 ************************************************************************************************************************
1064 */
ComputeSurfaceInfoTiled(const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR2_COMPUTE_SURFACE_INFO_OUTPUT * pOut) const1065 ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoTiled(
1066 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
1067 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
1068 ) const
1069 {
1070 return HwlComputeSurfaceInfoTiled(pIn, pOut);
1071 }
1072
1073 /**
1074 ************************************************************************************************************************
1075 * Lib::ComputeSurfaceAddrFromCoordLinear
1076 *
1077 * @brief
1078 * Internal function to calculate address from coord for linear swizzle surface
1079 *
1080 * @return
1081 * ADDR_E_RETURNCODE
1082 ************************************************************************************************************************
1083 */
ComputeSurfaceAddrFromCoordLinear(const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut) const1084 ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoordLinear(
1085 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
1086 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
1087 ) const
1088 {
1089 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1090 BOOL_32 valid = (pIn->numSamples <= 1) && (pIn->numFrags <= 1) && (pIn->pipeBankXor == 0);
1091
1092 if (valid)
1093 {
1094 if (IsTex1d(pIn->resourceType))
1095 {
1096 valid = (pIn->y == 0);
1097 }
1098 }
1099
1100 if (valid)
1101 {
1102 ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
1103 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
1104 ADDR2_MIP_INFO mipInfo[MaxMipLevels];
1105
1106 localIn.bpp = pIn->bpp;
1107 localIn.flags = pIn->flags;
1108 localIn.width = Max(pIn->unalignedWidth, 1u);
1109 localIn.height = Max(pIn->unalignedHeight, 1u);
1110 localIn.numSlices = Max(pIn->numSlices, 1u);
1111 localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
1112 localIn.resourceType = pIn->resourceType;
1113
1114 if (localIn.numMipLevels <= 1)
1115 {
1116 localIn.pitchInElement = pIn->pitchInElement;
1117 }
1118
1119 localOut.pMipInfo = mipInfo;
1120
1121 returnCode = ComputeSurfaceInfoLinear(&localIn, &localOut);
1122
1123 if (returnCode == ADDR_OK)
1124 {
1125 pOut->addr = (localOut.sliceSize * pIn->slice) +
1126 mipInfo[pIn->mipId].offset +
1127 (pIn->y * mipInfo[pIn->mipId].pitch + pIn->x) * (pIn->bpp >> 3);
1128 pOut->bitPosition = 0;
1129 }
1130 else
1131 {
1132 valid = FALSE;
1133 }
1134 }
1135
1136 if (valid == FALSE)
1137 {
1138 returnCode = ADDR_INVALIDPARAMS;
1139 }
1140
1141 return returnCode;
1142 }
1143
1144 /**
1145 ************************************************************************************************************************
1146 * Lib::ComputeSurfaceAddrFromCoordTiled
1147 *
1148 * @brief
1149 * Internal function to calculate address from coord for tiled swizzle surface
1150 *
1151 * @return
1152 * ADDR_E_RETURNCODE
1153 ************************************************************************************************************************
1154 */
ComputeSurfaceAddrFromCoordTiled(const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut) const1155 ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoordTiled(
1156 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
1157 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
1158 ) const
1159 {
1160 return HwlComputeSurfaceAddrFromCoordTiled(pIn, pOut);
1161 }
1162
1163 /**
1164 ************************************************************************************************************************
1165 * Lib::ComputeSurfaceCoordFromAddrLinear
1166 *
1167 * @brief
1168 * Internal function to calculate coord from address for linear swizzle surface
1169 *
1170 * @return
1171 * ADDR_E_RETURNCODE
1172 ************************************************************************************************************************
1173 */
ComputeSurfaceCoordFromAddrLinear(const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut) const1174 ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddrLinear(
1175 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
1176 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
1177 ) const
1178 {
1179 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1180
1181 BOOL_32 valid = (pIn->numSamples <= 1) && (pIn->numFrags <= 1);
1182
1183 if (valid)
1184 {
1185 if (IsTex1d(pIn->resourceType))
1186 {
1187 valid = (pIn->unalignedHeight == 1);
1188 }
1189 }
1190
1191 if (valid)
1192 {
1193 ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
1194 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
1195 localIn.bpp = pIn->bpp;
1196 localIn.flags = pIn->flags;
1197 localIn.width = Max(pIn->unalignedWidth, 1u);
1198 localIn.height = Max(pIn->unalignedHeight, 1u);
1199 localIn.numSlices = Max(pIn->numSlices, 1u);
1200 localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
1201 localIn.resourceType = pIn->resourceType;
1202 if (localIn.numMipLevels <= 1)
1203 {
1204 localIn.pitchInElement = pIn->pitchInElement;
1205 }
1206 returnCode = ComputeSurfaceInfoLinear(&localIn, &localOut);
1207
1208 if (returnCode == ADDR_OK)
1209 {
1210 pOut->slice = static_cast<UINT_32>(pIn->addr / localOut.sliceSize);
1211 pOut->sample = 0;
1212
1213 UINT_32 offsetInSlice = static_cast<UINT_32>(pIn->addr % localOut.sliceSize);
1214 UINT_32 elementBytes = pIn->bpp >> 3;
1215 UINT_32 mipOffsetInSlice = 0;
1216 UINT_32 mipSize = 0;
1217 UINT_32 mipId = 0;
1218 for (; mipId < pIn->numMipLevels ; mipId++)
1219 {
1220 if (IsTex1d(pIn->resourceType))
1221 {
1222 mipSize = localOut.pitch * elementBytes;
1223 }
1224 else
1225 {
1226 UINT_32 currentMipHeight = (PowTwoAlign(localIn.height, (1 << mipId))) >> mipId;
1227 mipSize = currentMipHeight * localOut.pitch * elementBytes;
1228 }
1229
1230 if (mipSize == 0)
1231 {
1232 valid = FALSE;
1233 break;
1234 }
1235 else if ((mipSize + mipOffsetInSlice) > offsetInSlice)
1236 {
1237 break;
1238 }
1239 else
1240 {
1241 mipOffsetInSlice += mipSize;
1242 if ((mipId == (pIn->numMipLevels - 1)) ||
1243 (mipOffsetInSlice >= localOut.sliceSize))
1244 {
1245 valid = FALSE;
1246 }
1247 }
1248 }
1249
1250 if (valid)
1251 {
1252 pOut->mipId = mipId;
1253
1254 UINT_32 elemOffsetInMip = (offsetInSlice - mipOffsetInSlice) / elementBytes;
1255 if (IsTex1d(pIn->resourceType))
1256 {
1257 if (elemOffsetInMip < localOut.pitch)
1258 {
1259 pOut->x = elemOffsetInMip;
1260 pOut->y = 0;
1261 }
1262 else
1263 {
1264 valid = FALSE;
1265 }
1266 }
1267 else
1268 {
1269 pOut->y = elemOffsetInMip / localOut.pitch;
1270 pOut->x = elemOffsetInMip % localOut.pitch;
1271 }
1272
1273 if ((pOut->slice >= pIn->numSlices) ||
1274 (pOut->mipId >= pIn->numMipLevels) ||
1275 (pOut->x >= Max((pIn->unalignedWidth >> pOut->mipId), 1u)) ||
1276 (pOut->y >= Max((pIn->unalignedHeight >> pOut->mipId), 1u)) ||
1277 (IsTex3d(pIn->resourceType) &&
1278 (FALSE == Valid3DMipSliceIdConstraint(pIn->numSlices,
1279 pOut->mipId,
1280 pOut->slice))))
1281 {
1282 valid = FALSE;
1283 }
1284 }
1285 }
1286 else
1287 {
1288 valid = FALSE;
1289 }
1290 }
1291
1292 if (valid == FALSE)
1293 {
1294 returnCode = ADDR_INVALIDPARAMS;
1295 }
1296
1297 return returnCode;
1298 }
1299
1300 /**
1301 ************************************************************************************************************************
1302 * Lib::ComputeSurfaceCoordFromAddrTiled
1303 *
1304 * @brief
1305 * Internal function to calculate coord from address for tiled swizzle surface
1306 *
1307 * @return
1308 * ADDR_E_RETURNCODE
1309 ************************************************************************************************************************
1310 */
ComputeSurfaceCoordFromAddrTiled(const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut) const1311 ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddrTiled(
1312 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
1313 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
1314 ) const
1315 {
1316 ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
1317
1318 ADDR_NOT_IMPLEMENTED();
1319
1320 return returnCode;
1321 }
1322
1323 /**
1324 ************************************************************************************************************************
1325 * Lib::ComputeBlockDimensionForSurf
1326 *
1327 * @brief
1328 * Internal function to get block width/height/depth in element from surface input params.
1329 *
1330 * @return
1331 * ADDR_E_RETURNCODE
1332 ************************************************************************************************************************
1333 */
ComputeBlockDimensionForSurf(UINT_32 * pWidth,UINT_32 * pHeight,UINT_32 * pDepth,UINT_32 bpp,UINT_32 numSamples,AddrResourceType resourceType,AddrSwizzleMode swizzleMode) const1334 ADDR_E_RETURNCODE Lib::ComputeBlockDimensionForSurf(
1335 UINT_32* pWidth,
1336 UINT_32* pHeight,
1337 UINT_32* pDepth,
1338 UINT_32 bpp,
1339 UINT_32 numSamples,
1340 AddrResourceType resourceType,
1341 AddrSwizzleMode swizzleMode) const
1342 {
1343 ADDR_E_RETURNCODE returnCode = ComputeBlockDimension(pWidth,
1344 pHeight,
1345 pDepth,
1346 bpp,
1347 resourceType,
1348 swizzleMode);
1349
1350 if ((returnCode == ADDR_OK) && (numSamples > 1) && IsThin(resourceType, swizzleMode))
1351 {
1352 const UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
1353 const UINT_32 log2sample = Log2(numSamples);
1354 const UINT_32 q = log2sample >> 1;
1355 const UINT_32 r = log2sample & 1;
1356
1357 if (log2blkSize & 1)
1358 {
1359 *pWidth >>= q;
1360 *pHeight >>= (q + r);
1361 }
1362 else
1363 {
1364 *pWidth >>= (q + r);
1365 *pHeight >>= q;
1366 }
1367 }
1368
1369 return returnCode;
1370 }
1371
1372 /**
1373 ************************************************************************************************************************
1374 * Lib::ComputeBlockDimension
1375 *
1376 * @brief
1377 * Internal function to get block width/height/depth in element without considering MSAA case
1378 *
1379 * @return
1380 * ADDR_E_RETURNCODE
1381 ************************************************************************************************************************
1382 */
ComputeBlockDimension(UINT_32 * pWidth,UINT_32 * pHeight,UINT_32 * pDepth,UINT_32 bpp,AddrResourceType resourceType,AddrSwizzleMode swizzleMode) const1383 ADDR_E_RETURNCODE Lib::ComputeBlockDimension(
1384 UINT_32* pWidth,
1385 UINT_32* pHeight,
1386 UINT_32* pDepth,
1387 UINT_32 bpp,
1388 AddrResourceType resourceType,
1389 AddrSwizzleMode swizzleMode) const
1390 {
1391 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1392
1393 UINT_32 eleBytes = bpp >> 3;
1394 UINT_32 microBlockSizeTableIndex = Log2(eleBytes);
1395 UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
1396
1397 if (IsThin(resourceType, swizzleMode))
1398 {
1399 UINT_32 log2blkSizeIn256B = log2blkSize - 8;
1400 UINT_32 widthAmp = log2blkSizeIn256B / 2;
1401 UINT_32 heightAmp = log2blkSizeIn256B - widthAmp;
1402
1403 ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block256_2d) / sizeof(Block256_2d[0]));
1404
1405 *pWidth = (Block256_2d[microBlockSizeTableIndex].w << widthAmp);
1406 *pHeight = (Block256_2d[microBlockSizeTableIndex].h << heightAmp);
1407 *pDepth = 1;
1408 }
1409 else if (IsThick(resourceType, swizzleMode))
1410 {
1411 UINT_32 log2blkSizeIn1KB = log2blkSize - 10;
1412 UINT_32 averageAmp = log2blkSizeIn1KB / 3;
1413 UINT_32 restAmp = log2blkSizeIn1KB % 3;
1414
1415 ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block1K_3d) / sizeof(Block1K_3d[0]));
1416
1417 *pWidth = Block1K_3d[microBlockSizeTableIndex].w << averageAmp;
1418 *pHeight = Block1K_3d[microBlockSizeTableIndex].h << (averageAmp + (restAmp / 2));
1419 *pDepth = Block1K_3d[microBlockSizeTableIndex].d << (averageAmp + ((restAmp != 0) ? 1 : 0));
1420 }
1421 else
1422 {
1423 ADDR_ASSERT_ALWAYS();
1424 returnCode = ADDR_INVALIDPARAMS;
1425 }
1426
1427 return returnCode;
1428 }
1429
1430 /**
1431 ************************************************************************************************************************
1432 * Lib::GetMipTailDim
1433 *
1434 * @brief
1435 * Internal function to get out max dimension of first level in mip tail
1436 *
1437 * @return
1438 * Max Width/Height/Depth value of the first mip fitted in mip tail
1439 ************************************************************************************************************************
1440 */
GetMipTailDim(AddrResourceType resourceType,AddrSwizzleMode swizzleMode,UINT_32 blockWidth,UINT_32 blockHeight,UINT_32 blockDepth) const1441 Dim3d Lib::GetMipTailDim(
1442 AddrResourceType resourceType,
1443 AddrSwizzleMode swizzleMode,
1444 UINT_32 blockWidth,
1445 UINT_32 blockHeight,
1446 UINT_32 blockDepth) const
1447 {
1448 Dim3d out = {blockWidth, blockHeight, blockDepth};
1449 UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
1450
1451 if (IsThick(resourceType, swizzleMode))
1452 {
1453 UINT_32 dim = log2blkSize % 3;
1454
1455 if (dim == 0)
1456 {
1457 out.h >>= 1;
1458 }
1459 else if (dim == 1)
1460 {
1461 out.w >>= 1;
1462 }
1463 else
1464 {
1465 out.d >>= 1;
1466 }
1467 }
1468 else
1469 {
1470 if (log2blkSize & 1)
1471 {
1472 out.h >>= 1;
1473 }
1474 else
1475 {
1476 out.w >>= 1;
1477 }
1478 }
1479
1480 return out;
1481 }
1482
1483 /**
1484 ************************************************************************************************************************
1485 * Lib::ComputeSurface2DMicroBlockOffset
1486 *
1487 * @brief
1488 * Internal function to calculate micro block (256B) offset from coord for 2D resource
1489 *
1490 * @return
1491 * micro block (256B) offset for 2D resource
1492 ************************************************************************************************************************
1493 */
ComputeSurface2DMicroBlockOffset(const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn) const1494 UINT_32 Lib::ComputeSurface2DMicroBlockOffset(
1495 const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const
1496 {
1497 ADDR_ASSERT(IsThin(pIn->resourceType, pIn->swizzleMode));
1498
1499 UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
1500 UINT_32 microBlockOffset = 0;
1501 if (IsStandardSwizzle(pIn->resourceType, pIn->swizzleMode))
1502 {
1503 UINT_32 xBits = pIn->x << log2ElementBytes;
1504 microBlockOffset = (xBits & 0xf) | ((pIn->y & 0x3) << 4);
1505 if (log2ElementBytes < 3)
1506 {
1507 microBlockOffset |= (pIn->y & 0x4) << 4;
1508 if (log2ElementBytes == 0)
1509 {
1510 microBlockOffset |= (pIn->y & 0x8) << 4;
1511 }
1512 else
1513 {
1514 microBlockOffset |= (xBits & 0x10) << 3;
1515 }
1516 }
1517 else
1518 {
1519 microBlockOffset |= (xBits & 0x30) << 2;
1520 }
1521 }
1522 else if (IsDisplaySwizzle(pIn->resourceType, pIn->swizzleMode))
1523 {
1524 if (log2ElementBytes == 4)
1525 {
1526 microBlockOffset = (GetBit(pIn->x, 0) << 4) |
1527 (GetBit(pIn->y, 0) << 5) |
1528 (GetBit(pIn->x, 1) << 6) |
1529 (GetBit(pIn->y, 1) << 7);
1530 }
1531 else
1532 {
1533 microBlockOffset = GetBits(pIn->x, 0, 3, log2ElementBytes) |
1534 GetBits(pIn->y, 1, 2, 3 + log2ElementBytes) |
1535 GetBits(pIn->x, 3, 1, 5 + log2ElementBytes) |
1536 GetBits(pIn->y, 3, 1, 6 + log2ElementBytes);
1537 microBlockOffset = GetBits(microBlockOffset, 0, 4, 0) |
1538 (GetBit(pIn->y, 0) << 4) |
1539 GetBits(microBlockOffset, 4, 3, 5);
1540 }
1541 }
1542 else if (IsRotateSwizzle(pIn->swizzleMode))
1543 {
1544 microBlockOffset = GetBits(pIn->y, 0, 3, log2ElementBytes) |
1545 GetBits(pIn->x, 1, 2, 3 + log2ElementBytes) |
1546 GetBits(pIn->x, 3, 1, 5 + log2ElementBytes) |
1547 GetBits(pIn->y, 3, 1, 6 + log2ElementBytes);
1548 microBlockOffset = GetBits(microBlockOffset, 0, 4, 0) |
1549 (GetBit(pIn->x, 0) << 4) |
1550 GetBits(microBlockOffset, 4, 3, 5);
1551 if (log2ElementBytes == 3)
1552 {
1553 microBlockOffset = GetBits(microBlockOffset, 0, 6, 0) |
1554 GetBits(pIn->x, 1, 2, 6);
1555 }
1556 }
1557
1558 return microBlockOffset;
1559 }
1560
1561 /**
1562 ************************************************************************************************************************
1563 * Lib::ComputeSurface3DMicroBlockOffset
1564 *
1565 * @brief
1566 * Internal function to calculate micro block (1KB) offset from coord for 3D resource
1567 *
1568 * @return
1569 * micro block (1KB) offset for 3D resource
1570 ************************************************************************************************************************
1571 */
ComputeSurface3DMicroBlockOffset(const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn) const1572 UINT_32 Lib::ComputeSurface3DMicroBlockOffset(
1573 const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const
1574 {
1575 ADDR_ASSERT(IsThick(pIn->resourceType, pIn->swizzleMode));
1576
1577 UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
1578 UINT_32 microBlockOffset = 0;
1579 if (IsStandardSwizzle(pIn->resourceType, pIn->swizzleMode))
1580 {
1581 if (log2ElementBytes == 0)
1582 {
1583 microBlockOffset = ((pIn->slice & 4) >> 2) | ((pIn->y & 4) >> 1);
1584 }
1585 else if (log2ElementBytes == 1)
1586 {
1587 microBlockOffset = ((pIn->slice & 4) >> 2) | ((pIn->y & 4) >> 1);
1588 }
1589 else if (log2ElementBytes == 2)
1590 {
1591 microBlockOffset = ((pIn->y & 4) >> 2) | ((pIn->x & 4) >> 1);
1592 }
1593 else if (log2ElementBytes == 3)
1594 {
1595 microBlockOffset = (pIn->x & 6) >> 1;
1596 }
1597 else
1598 {
1599 microBlockOffset = pIn->x & 3;
1600 }
1601
1602 microBlockOffset <<= 8;
1603
1604 UINT_32 xBits = pIn->x << log2ElementBytes;
1605 microBlockOffset |= (xBits & 0xf) | ((pIn->y & 0x3) << 4) | ((pIn->slice & 0x3) << 6);
1606 }
1607 else if (IsZOrderSwizzle(pIn->swizzleMode))
1608 {
1609 UINT_32 xh, yh, zh;
1610
1611 if (log2ElementBytes == 0)
1612 {
1613 microBlockOffset =
1614 (pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->x & 2) << 1) | ((pIn->y & 2) << 2);
1615 microBlockOffset = microBlockOffset | ((pIn->slice & 3) << 4) | ((pIn->x & 4) << 4);
1616
1617 xh = pIn->x >> 3;
1618 yh = pIn->y >> 2;
1619 zh = pIn->slice >> 2;
1620 }
1621 else if (log2ElementBytes == 1)
1622 {
1623 microBlockOffset =
1624 (pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->x & 2) << 1) | ((pIn->y & 2) << 2);
1625 microBlockOffset = (microBlockOffset << 1) | ((pIn->slice & 3) << 5);
1626
1627 xh = pIn->x >> 2;
1628 yh = pIn->y >> 2;
1629 zh = pIn->slice >> 2;
1630 }
1631 else if (log2ElementBytes == 2)
1632 {
1633 microBlockOffset =
1634 (pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->x & 2) << 1) | ((pIn->slice & 1) << 3);
1635 microBlockOffset = (microBlockOffset << 2) | ((pIn->y & 2) << 5);
1636
1637 xh = pIn->x >> 2;
1638 yh = pIn->y >> 2;
1639 zh = pIn->slice >> 1;
1640 }
1641 else if (log2ElementBytes == 3)
1642 {
1643 microBlockOffset =
1644 (pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->slice & 1) << 2) | ((pIn->x & 2) << 2);
1645 microBlockOffset <<= 3;
1646
1647 xh = pIn->x >> 2;
1648 yh = pIn->y >> 1;
1649 zh = pIn->slice >> 1;
1650 }
1651 else
1652 {
1653 microBlockOffset =
1654 (((pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->slice & 1) << 2)) << 4);
1655
1656 xh = pIn->x >> 1;
1657 yh = pIn->y >> 1;
1658 zh = pIn->slice >> 1;
1659 }
1660
1661 microBlockOffset |= ((MortonGen3d(xh, yh, zh, 1) << 7) & 0x380);
1662 }
1663
1664 return microBlockOffset;
1665 }
1666
1667 /**
1668 ************************************************************************************************************************
1669 * Lib::GetPipeXorBits
1670 *
1671 * @brief
1672 * Internal function to get bits number for pipe/se xor operation
1673 *
1674 * @return
1675 * ADDR_E_RETURNCODE
1676 ************************************************************************************************************************
1677 */
GetPipeXorBits(UINT_32 macroBlockBits) const1678 UINT_32 Lib::GetPipeXorBits(
1679 UINT_32 macroBlockBits) const
1680 {
1681 ADDR_ASSERT(macroBlockBits >= m_pipeInterleaveLog2);
1682
1683 // Total available xor bits
1684 UINT_32 xorBits = macroBlockBits - m_pipeInterleaveLog2;
1685
1686 // Pipe/Se xor bits
1687 UINT_32 pipeBits = Min(xorBits, m_pipesLog2 + m_seLog2);
1688
1689 return pipeBits;
1690 }
1691
1692 /**
1693 ************************************************************************************************************************
1694 * Lib::GetBankXorBits
1695 *
1696 * @brief
1697 * Internal function to get bits number for pipe/se xor operation
1698 *
1699 * @return
1700 * ADDR_E_RETURNCODE
1701 ************************************************************************************************************************
1702 */
GetBankXorBits(UINT_32 macroBlockBits) const1703 UINT_32 Lib::GetBankXorBits(
1704 UINT_32 macroBlockBits) const
1705 {
1706 UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
1707
1708 // Bank xor bits
1709 UINT_32 bankBits = Min(macroBlockBits - pipeBits - m_pipeInterleaveLog2, m_banksLog2);
1710
1711 return bankBits;
1712 }
1713
1714 /**
1715 ************************************************************************************************************************
1716 * Lib::Addr2GetPreferredSurfaceSetting
1717 *
1718 * @brief
1719 * Internal function to get suggested surface information for cliet to use
1720 *
1721 * @return
1722 * ADDR_E_RETURNCODE
1723 ************************************************************************************************************************
1724 */
Addr2GetPreferredSurfaceSetting(const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT * pIn,ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT * pOut) const1725 ADDR_E_RETURNCODE Lib::Addr2GetPreferredSurfaceSetting(
1726 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
1727 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const
1728 {
1729 ADDR_E_RETURNCODE returnCode;
1730
1731 if ((GetFillSizeFieldsFlags() == TRUE) &&
1732 ((pIn->size != sizeof(ADDR2_GET_PREFERRED_SURF_SETTING_INPUT)) ||
1733 (pOut->size != sizeof(ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT))))
1734 {
1735 returnCode = ADDR_INVALIDPARAMS;
1736 }
1737 else
1738 {
1739 returnCode = HwlGetPreferredSurfaceSetting(pIn, pOut);
1740 }
1741
1742 return returnCode;
1743 }
1744
1745 /**
1746 ************************************************************************************************************************
1747 * Lib::ComputeBlock256Equation
1748 *
1749 * @brief
1750 * Compute equation for block 256B
1751 *
1752 * @return
1753 * If equation computed successfully
1754 *
1755 ************************************************************************************************************************
1756 */
ComputeBlock256Equation(AddrResourceType rsrcType,AddrSwizzleMode swMode,UINT_32 elementBytesLog2,ADDR_EQUATION * pEquation) const1757 ADDR_E_RETURNCODE Lib::ComputeBlock256Equation(
1758 AddrResourceType rsrcType,
1759 AddrSwizzleMode swMode,
1760 UINT_32 elementBytesLog2,
1761 ADDR_EQUATION* pEquation) const
1762 {
1763 ADDR_E_RETURNCODE ret;
1764
1765 if (IsBlock256b(swMode))
1766 {
1767 ret = HwlComputeBlock256Equation(rsrcType, swMode, elementBytesLog2, pEquation);
1768 }
1769 else
1770 {
1771 ADDR_ASSERT_ALWAYS();
1772 ret = ADDR_INVALIDPARAMS;
1773 }
1774
1775 return ret;
1776 }
1777
1778 /**
1779 ************************************************************************************************************************
1780 * Lib::ComputeThinEquation
1781 *
1782 * @brief
1783 * Compute equation for 2D/3D resource which use THIN mode
1784 *
1785 * @return
1786 * If equation computed successfully
1787 *
1788 ************************************************************************************************************************
1789 */
ComputeThinEquation(AddrResourceType rsrcType,AddrSwizzleMode swMode,UINT_32 elementBytesLog2,ADDR_EQUATION * pEquation) const1790 ADDR_E_RETURNCODE Lib::ComputeThinEquation(
1791 AddrResourceType rsrcType,
1792 AddrSwizzleMode swMode,
1793 UINT_32 elementBytesLog2,
1794 ADDR_EQUATION* pEquation) const
1795 {
1796 ADDR_E_RETURNCODE ret;
1797
1798 if (IsThin(rsrcType, swMode))
1799 {
1800 ret = HwlComputeThinEquation(rsrcType, swMode, elementBytesLog2, pEquation);
1801 }
1802 else
1803 {
1804 ADDR_ASSERT_ALWAYS();
1805 ret = ADDR_INVALIDPARAMS;
1806 }
1807
1808 return ret;
1809 }
1810
1811 /**
1812 ************************************************************************************************************************
1813 * Lib::ComputeThickEquation
1814 *
1815 * @brief
1816 * Compute equation for 3D resource which use THICK mode
1817 *
1818 * @return
1819 * If equation computed successfully
1820 *
1821 ************************************************************************************************************************
1822 */
ComputeThickEquation(AddrResourceType rsrcType,AddrSwizzleMode swMode,UINT_32 elementBytesLog2,ADDR_EQUATION * pEquation) const1823 ADDR_E_RETURNCODE Lib::ComputeThickEquation(
1824 AddrResourceType rsrcType,
1825 AddrSwizzleMode swMode,
1826 UINT_32 elementBytesLog2,
1827 ADDR_EQUATION* pEquation) const
1828 {
1829 ADDR_E_RETURNCODE ret;
1830
1831 if (IsThick(rsrcType, swMode))
1832 {
1833 ret = HwlComputeThickEquation(rsrcType, swMode, elementBytesLog2, pEquation);
1834 }
1835 else
1836 {
1837 ADDR_ASSERT_ALWAYS();
1838 ret = ADDR_INVALIDPARAMS;
1839 }
1840
1841 return ret;
1842 }
1843
1844 /**
1845 ************************************************************************************************************************
1846 * Lib::ComputeQbStereoInfo
1847 *
1848 * @brief
1849 * Get quad buffer stereo information
1850 * @return
1851 * N/A
1852 ************************************************************************************************************************
1853 */
ComputeQbStereoInfo(ADDR2_COMPUTE_SURFACE_INFO_OUTPUT * pOut) const1854 VOID Lib::ComputeQbStereoInfo(
1855 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in,out] updated pOut+pStereoInfo
1856 ) const
1857 {
1858 ADDR_ASSERT(pOut->bpp >= 8);
1859 ADDR_ASSERT((pOut->surfSize % pOut->baseAlign) == 0);
1860
1861 // Save original height
1862 pOut->pStereoInfo->eyeHeight = pOut->height;
1863
1864 // Right offset
1865 pOut->pStereoInfo->rightOffset = static_cast<UINT_32>(pOut->surfSize);
1866
1867 // Double height
1868 pOut->height <<= 1;
1869
1870 ADDR_ASSERT(pOut->height <= MaxSurfaceHeight);
1871
1872 pOut->pixelHeight <<= 1;
1873
1874 // Double size
1875 pOut->surfSize <<= 1;
1876 }
1877
1878
1879 } // V2
1880 } // Addr
1881
1882