1 /*
2 ************************************************************************************************************************
3 *
4 * Copyright (C) 2007-2022 Advanced Micro Devices, Inc. All rights reserved.
5 * SPDX-License-Identifier: MIT
6 *
7 ***********************************************************************************************************************/
8
9 /**
10 ****************************************************************************************************
11 * @file addrinterface.cpp
12 * @brief Contains the addrlib interface functions
13 ****************************************************************************************************
14 */
15 #include "addrinterface.h"
16 #include "addrlib1.h"
17 #include "addrlib2.h"
18 #include "addrlib3.h"
19
20 #include "addrcommon.h"
21
22 using namespace Addr;
23
24 ////////////////////////////////////////////////////////////////////////////////////////////////////
25 // Create/Destroy/Config functions
26 ////////////////////////////////////////////////////////////////////////////////////////////////////
27
28 /**
29 ****************************************************************************************************
30 * AddrCreate
31 *
32 * @brief
33 * Create address lib object
34 *
35 * @return
36 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
37 ****************************************************************************************************
38 */
AddrCreate(const ADDR_CREATE_INPUT * pAddrCreateIn,ADDR_CREATE_OUTPUT * pAddrCreateOut)39 ADDR_E_RETURNCODE ADDR_API AddrCreate(
40 const ADDR_CREATE_INPUT* pAddrCreateIn, ///< [in] infomation for creating address lib object
41 ADDR_CREATE_OUTPUT* pAddrCreateOut) ///< [out] address lib handle
42 {
43 ADDR_E_RETURNCODE returnCode = ADDR_OK;
44 {
45 returnCode = Lib::Create(pAddrCreateIn, pAddrCreateOut);
46 }
47
48 ADDR_RESET_DEBUG_PRINTERS();
49 return returnCode;
50 }
51
52
53
54 /**
55 ****************************************************************************************************
56 * AddrDestroy
57 *
58 * @brief
59 * Destroy address lib object
60 *
61 * @return
62 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
63 ****************************************************************************************************
64 */
AddrDestroy(ADDR_HANDLE hLib)65 ADDR_E_RETURNCODE ADDR_API AddrDestroy(
66 ADDR_HANDLE hLib) ///< address lib handle
67 {
68 ADDR_E_RETURNCODE returnCode = ADDR_OK;
69
70 if (hLib)
71 {
72 Lib* pLib = Lib::GetLib(hLib);
73 pLib->Destroy();
74 }
75 else
76 {
77 returnCode = ADDR_ERROR;
78 }
79
80 ADDR_RESET_DEBUG_PRINTERS();
81 return returnCode;
82 }
83
84
85 ////////////////////////////////////////////////////////////////////////////////////////////////////
86 // Surface functions
87 ////////////////////////////////////////////////////////////////////////////////////////////////////
88
89 /**
90 ****************************************************************************************************
91 * AddrComputeSurfaceInfo
92 *
93 * @brief
94 * Calculate surface width/height/depth/alignments and suitable tiling mode
95 *
96 * @return
97 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
98 ****************************************************************************************************
99 */
AddrComputeSurfaceInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR_COMPUTE_SURFACE_INFO_OUTPUT * pOut)100 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
101 ADDR_HANDLE hLib, ///< address lib handle
102 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
103 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
104 {
105 V1::Lib* pLib = V1::Lib::GetLib(hLib);
106
107 ADDR_E_RETURNCODE returnCode = ADDR_OK;
108
109 if (pLib != NULL)
110 {
111 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
112 }
113 else
114 {
115 returnCode = ADDR_ERROR;
116 }
117
118 ADDR_RESET_DEBUG_PRINTERS();
119 return returnCode;
120 }
121
122
123
124 /**
125 ****************************************************************************************************
126 * AddrComputeSurfaceAddrFromCoord
127 *
128 * @brief
129 * Compute surface address according to coordinates
130 *
131 * @return
132 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
133 ****************************************************************************************************
134 */
AddrComputeSurfaceAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)135 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
136 ADDR_HANDLE hLib, ///< address lib handle
137 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
138 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
139 {
140 V1::Lib* pLib = V1::Lib::GetLib(hLib);
141
142 ADDR_E_RETURNCODE returnCode = ADDR_OK;
143
144 if (pLib != NULL)
145 {
146 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
147 }
148 else
149 {
150 returnCode = ADDR_ERROR;
151 }
152
153 ADDR_RESET_DEBUG_PRINTERS();
154 return returnCode;
155 }
156
157 /**
158 ****************************************************************************************************
159 * AddrComputeSurfaceCoordFromAddr
160 *
161 * @brief
162 * Compute coordinates according to surface address
163 *
164 * @return
165 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
166 ****************************************************************************************************
167 */
AddrComputeSurfaceCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut)168 ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
169 ADDR_HANDLE hLib, ///< address lib handle
170 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address
171 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates
172 {
173 V1::Lib* pLib = V1::Lib::GetLib(hLib);
174
175 ADDR_E_RETURNCODE returnCode = ADDR_OK;
176
177 if (pLib != NULL)
178 {
179 returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
180 }
181 else
182 {
183 returnCode = ADDR_ERROR;
184 }
185
186 ADDR_RESET_DEBUG_PRINTERS();
187 return returnCode;
188 }
189
190
191
192 ////////////////////////////////////////////////////////////////////////////////////////////////////
193 // HTile functions
194 ////////////////////////////////////////////////////////////////////////////////////////////////////
195
196 /**
197 ****************************************************************************************************
198 * AddrComputeHtileInfo
199 *
200 * @brief
201 * Compute Htile pitch, height, base alignment and size in bytes
202 *
203 * @return
204 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
205 ****************************************************************************************************
206 */
AddrComputeHtileInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_HTILE_INFO_INPUT * pIn,ADDR_COMPUTE_HTILE_INFO_OUTPUT * pOut)207 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
208 ADDR_HANDLE hLib, ///< address lib handle
209 const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information
210 ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes
211 {
212 V1::Lib* pLib = V1::Lib::GetLib(hLib);
213
214 ADDR_E_RETURNCODE returnCode = ADDR_OK;
215
216 if (pLib != NULL)
217 {
218 returnCode = pLib->ComputeHtileInfo(pIn, pOut);
219 }
220 else
221 {
222 returnCode = ADDR_ERROR;
223 }
224
225 ADDR_RESET_DEBUG_PRINTERS();
226 return returnCode;
227 }
228
229 /**
230 ****************************************************************************************************
231 * AddrComputeHtileAddrFromCoord
232 *
233 * @brief
234 * Compute Htile address according to coordinates (of depth buffer)
235 *
236 * @return
237 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
238 ****************************************************************************************************
239 */
AddrComputeHtileAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT * pOut)240 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
241 ADDR_HANDLE hLib, ///< address lib handle
242 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates
243 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address
244 {
245 V1::Lib* pLib = V1::Lib::GetLib(hLib);
246
247 ADDR_E_RETURNCODE returnCode = ADDR_OK;
248
249 if (pLib != NULL)
250 {
251 returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
252 }
253 else
254 {
255 returnCode = ADDR_ERROR;
256 }
257
258 ADDR_RESET_DEBUG_PRINTERS();
259 return returnCode;
260 }
261
262 /**
263 ****************************************************************************************************
264 * AddrComputeHtileCoordFromAddr
265 *
266 * @brief
267 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
268 * Htile address
269 *
270 * @return
271 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
272 ****************************************************************************************************
273 */
AddrComputeHtileCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT * pOut)274 ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
275 ADDR_HANDLE hLib, ///< address lib handle
276 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address
277 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates
278 {
279 V1::Lib* pLib = V1::Lib::GetLib(hLib);
280
281 ADDR_E_RETURNCODE returnCode = ADDR_OK;
282
283 if (pLib != NULL)
284 {
285 returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
286 }
287 else
288 {
289 returnCode = ADDR_ERROR;
290 }
291
292 ADDR_RESET_DEBUG_PRINTERS();
293 return returnCode;
294 }
295
296
297
298 ////////////////////////////////////////////////////////////////////////////////////////////////////
299 // C-mask functions
300 ////////////////////////////////////////////////////////////////////////////////////////////////////
301
302 /**
303 ****************************************************************************************************
304 * AddrComputeCmaskInfo
305 *
306 * @brief
307 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
308 * info
309 *
310 * @return
311 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
312 ****************************************************************************************************
313 */
AddrComputeCmaskInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_CMASK_INFO_INPUT * pIn,ADDR_COMPUTE_CMASK_INFO_OUTPUT * pOut)314 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
315 ADDR_HANDLE hLib, ///< address lib handle
316 const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height
317 ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes
318 {
319 V1::Lib* pLib = V1::Lib::GetLib(hLib);
320
321 ADDR_E_RETURNCODE returnCode = ADDR_OK;
322
323 if (pLib != NULL)
324 {
325 returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
326 }
327 else
328 {
329 returnCode = ADDR_ERROR;
330 }
331
332 ADDR_RESET_DEBUG_PRINTERS();
333 return returnCode;
334 }
335
336 /**
337 ****************************************************************************************************
338 * AddrComputeCmaskAddrFromCoord
339 *
340 * @brief
341 * Compute Cmask address according to coordinates (of MSAA color buffer)
342 *
343 * @return
344 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
345 ****************************************************************************************************
346 */
AddrComputeCmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT * pOut)347 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
348 ADDR_HANDLE hLib, ///< address lib handle
349 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates
350 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address
351 {
352 V1::Lib* pLib = V1::Lib::GetLib(hLib);
353
354 ADDR_E_RETURNCODE returnCode = ADDR_OK;
355
356 if (pLib != NULL)
357 {
358 returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
359 }
360 else
361 {
362 returnCode = ADDR_ERROR;
363 }
364
365 ADDR_RESET_DEBUG_PRINTERS();
366 return returnCode;
367 }
368
369 /**
370 ****************************************************************************************************
371 * AddrComputeCmaskCoordFromAddr
372 *
373 * @brief
374 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
375 * Cmask address
376 *
377 * @return
378 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
379 ****************************************************************************************************
380 */
AddrComputeCmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT * pOut)381 ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
382 ADDR_HANDLE hLib, ///< address lib handle
383 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address
384 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates
385 {
386 V1::Lib* pLib = V1::Lib::GetLib(hLib);
387
388 ADDR_E_RETURNCODE returnCode = ADDR_OK;
389
390 if (pLib != NULL)
391 {
392 returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
393 }
394 else
395 {
396 returnCode = ADDR_ERROR;
397 }
398
399 ADDR_RESET_DEBUG_PRINTERS();
400 return returnCode;
401 }
402
403
404
405 ////////////////////////////////////////////////////////////////////////////////////////////////////
406 // F-mask functions
407 ////////////////////////////////////////////////////////////////////////////////////////////////////
408
409 /**
410 ****************************************************************************************************
411 * AddrComputeFmaskInfo
412 *
413 * @brief
414 * Compute Fmask pitch/height/depth/alignments and size in bytes
415 *
416 * @return
417 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
418 ****************************************************************************************************
419 */
AddrComputeFmaskInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_FMASK_INFO_INPUT * pIn,ADDR_COMPUTE_FMASK_INFO_OUTPUT * pOut)420 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
421 ADDR_HANDLE hLib, ///< address lib handle
422 const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information
423 ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height
424 {
425 V1::Lib* pLib = V1::Lib::GetLib(hLib);
426
427 ADDR_E_RETURNCODE returnCode = ADDR_OK;
428
429 if (pLib != NULL)
430 {
431 returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
432 }
433 else
434 {
435 returnCode = ADDR_ERROR;
436 }
437
438 ADDR_RESET_DEBUG_PRINTERS();
439 return returnCode;
440 }
441
442 /**
443 ****************************************************************************************************
444 * AddrComputeFmaskAddrFromCoord
445 *
446 * @brief
447 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
448 *
449 * @return
450 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
451 ****************************************************************************************************
452 */
AddrComputeFmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT * pIn,ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT * pOut)453 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
454 ADDR_HANDLE hLib, ///< address lib handle
455 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates
456 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address
457 {
458 V1::Lib* pLib = V1::Lib::GetLib(hLib);
459
460 ADDR_E_RETURNCODE returnCode = ADDR_OK;
461
462 if (pLib != NULL)
463 {
464 returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
465 }
466 else
467 {
468 returnCode = ADDR_ERROR;
469 }
470
471 ADDR_RESET_DEBUG_PRINTERS();
472 return returnCode;
473 }
474
475 /**
476 ****************************************************************************************************
477 * AddrComputeFmaskCoordFromAddr
478 *
479 * @brief
480 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
481 *
482 * @return
483 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
484 ****************************************************************************************************
485 */
AddrComputeFmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT * pIn,ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT * pOut)486 ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
487 ADDR_HANDLE hLib, ///< address lib handle
488 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address
489 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates
490 {
491 V1::Lib* pLib = V1::Lib::GetLib(hLib);
492
493 ADDR_E_RETURNCODE returnCode = ADDR_OK;
494
495 if (pLib != NULL)
496 {
497 returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
498 }
499 else
500 {
501 returnCode = ADDR_ERROR;
502 }
503
504 ADDR_RESET_DEBUG_PRINTERS();
505 return returnCode;
506 }
507
508
509
510 ////////////////////////////////////////////////////////////////////////////////////////////////////
511 // DCC key functions
512 ////////////////////////////////////////////////////////////////////////////////////////////////////
513
514 /**
515 ****************************************************************************************************
516 * AddrComputeDccInfo
517 *
518 * @brief
519 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
520 *
521 ****************************************************************************************************
522 */
AddrComputeDccInfo(ADDR_HANDLE hLib,const ADDR_COMPUTE_DCCINFO_INPUT * pIn,ADDR_COMPUTE_DCCINFO_OUTPUT * pOut)523 ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
524 ADDR_HANDLE hLib, ///< handle of addrlib
525 const ADDR_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input
526 ADDR_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output
527 {
528 ADDR_E_RETURNCODE returnCode;
529
530 V1::Lib* pLib = V1::Lib::GetLib(hLib);
531
532 if (pLib != NULL)
533 {
534 returnCode = pLib->ComputeDccInfo(pIn, pOut);
535 }
536 else
537 {
538 returnCode = ADDR_ERROR;
539 }
540
541 ADDR_RESET_DEBUG_PRINTERS();
542 return returnCode;
543 }
544
545
546 ///////////////////////////////////////////////////////////////////////////////
547 // Below functions are element related or helper functions
548 ///////////////////////////////////////////////////////////////////////////////
549
550 /**
551 ****************************************************************************************************
552 * AddrGetVersion
553 *
554 * @brief
555 * Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
556 * defined in addrinterface.h to see if there is a mismatch.
557 ****************************************************************************************************
558 */
AddrGetVersion(ADDR_HANDLE hLib)559 UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib)
560 {
561 UINT_32 version = 0;
562
563 Addr::Lib* pLib = Lib::GetLib(hLib);
564
565 ADDR_ASSERT(pLib != NULL);
566
567 if (pLib)
568 {
569 version = pLib->GetVersion();
570 }
571
572 ADDR_RESET_DEBUG_PRINTERS();
573 return version;
574 }
575
576 /**
577 ****************************************************************************************************
578 * AddrUseTileIndex
579 *
580 * @brief
581 * Return TRUE if tileIndex is enabled in this address library
582 ****************************************************************************************************
583 */
AddrUseTileIndex(ADDR_HANDLE hLib)584 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
585 {
586 BOOL_32 useTileIndex = FALSE;
587
588 V1::Lib* pLib = V1::Lib::GetLib(hLib);
589
590 ADDR_ASSERT(pLib != NULL);
591
592 if (pLib)
593 {
594 useTileIndex = pLib->UseTileIndex(0);
595 }
596
597 ADDR_RESET_DEBUG_PRINTERS();
598 return useTileIndex;
599 }
600
601 /**
602 ****************************************************************************************************
603 * AddrUseCombinedSwizzle
604 *
605 * @brief
606 * Return TRUE if combined swizzle is enabled in this address library
607 ****************************************************************************************************
608 */
AddrUseCombinedSwizzle(ADDR_HANDLE hLib)609 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
610 {
611 BOOL_32 useCombinedSwizzle = FALSE;
612
613 V1::Lib* pLib = V1::Lib::GetLib(hLib);
614
615 ADDR_ASSERT(pLib != NULL);
616
617 if (pLib)
618 {
619 useCombinedSwizzle = pLib->UseCombinedSwizzle();
620 }
621
622 ADDR_RESET_DEBUG_PRINTERS();
623 return useCombinedSwizzle;
624 }
625
626 /**
627 ****************************************************************************************************
628 * AddrExtractBankPipeSwizzle
629 *
630 * @brief
631 * Extract Bank and Pipe swizzle from base256b
632 * @return
633 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
634 ****************************************************************************************************
635 */
AddrExtractBankPipeSwizzle(ADDR_HANDLE hLib,const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT * pIn,ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT * pOut)636 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
637 ADDR_HANDLE hLib, ///< addrlib handle
638 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
639 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) ///< [out] output structure
640 {
641 ADDR_E_RETURNCODE returnCode = ADDR_OK;
642
643 V1::Lib* pLib = V1::Lib::GetLib(hLib);
644
645 if (pLib != NULL)
646 {
647 returnCode = pLib->ExtractBankPipeSwizzle(pIn, pOut);
648 }
649 else
650 {
651 returnCode = ADDR_ERROR;
652 }
653
654 ADDR_RESET_DEBUG_PRINTERS();
655 return returnCode;
656 }
657
658 /**
659 ****************************************************************************************************
660 * AddrCombineBankPipeSwizzle
661 *
662 * @brief
663 * Combine Bank and Pipe swizzle
664 * @return
665 * ADDR_E_RETURNCODE
666 ****************************************************************************************************
667 */
AddrCombineBankPipeSwizzle(ADDR_HANDLE hLib,const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT * pIn,ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT * pOut)668 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
669 ADDR_HANDLE hLib,
670 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn,
671 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut)
672 {
673 ADDR_E_RETURNCODE returnCode = ADDR_OK;
674
675 V1::Lib* pLib = V1::Lib::GetLib(hLib);
676
677 if (pLib != NULL)
678 {
679 returnCode = pLib->CombineBankPipeSwizzle(pIn, pOut);
680 }
681 else
682 {
683 returnCode = ADDR_ERROR;
684 }
685
686 ADDR_RESET_DEBUG_PRINTERS();
687 return returnCode;
688 }
689
690 /**
691 ****************************************************************************************************
692 * AddrComputeSliceSwizzle
693 *
694 * @brief
695 * Compute a swizzle for slice from a base swizzle
696 * @return
697 * ADDR_OK if no error
698 ****************************************************************************************************
699 */
AddrComputeSliceSwizzle(ADDR_HANDLE hLib,const ADDR_COMPUTE_SLICESWIZZLE_INPUT * pIn,ADDR_COMPUTE_SLICESWIZZLE_OUTPUT * pOut)700 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
701 ADDR_HANDLE hLib,
702 const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn,
703 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut)
704 {
705 ADDR_E_RETURNCODE returnCode = ADDR_OK;
706
707 V1::Lib* pLib = V1::Lib::GetLib(hLib);
708
709 if (pLib != NULL)
710 {
711 returnCode = pLib->ComputeSliceTileSwizzle(pIn, pOut);
712 }
713 else
714 {
715 returnCode = ADDR_ERROR;
716 }
717
718 ADDR_RESET_DEBUG_PRINTERS();
719 return returnCode;
720 }
721
722 /**
723 ****************************************************************************************************
724 * AddrComputeBaseSwizzle
725 *
726 * @brief
727 * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
728 * @return
729 * ADDR_OK if no error
730 ****************************************************************************************************
731 */
AddrComputeBaseSwizzle(ADDR_HANDLE hLib,const ADDR_COMPUTE_BASE_SWIZZLE_INPUT * pIn,ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT * pOut)732 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
733 ADDR_HANDLE hLib,
734 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
735 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut)
736 {
737 ADDR_E_RETURNCODE returnCode = ADDR_OK;
738
739 V1::Lib* pLib = V1::Lib::GetLib(hLib);
740
741 if (pLib != NULL)
742 {
743 returnCode = pLib->ComputeBaseSwizzle(pIn, pOut);
744 }
745 else
746 {
747 returnCode = ADDR_ERROR;
748 }
749
750 ADDR_RESET_DEBUG_PRINTERS();
751 return returnCode;
752 }
753
754 /**
755 ****************************************************************************************************
756 * ElemFlt32ToDepthPixel
757 *
758 * @brief
759 * Convert a FLT_32 value to a depth/stencil pixel value
760 *
761 * @return
762 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
763 *
764 ****************************************************************************************************
765 */
ElemFlt32ToDepthPixel(ADDR_HANDLE hLib,const ELEM_FLT32TODEPTHPIXEL_INPUT * pIn,ELEM_FLT32TODEPTHPIXEL_OUTPUT * pOut)766 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
767 ADDR_HANDLE hLib, ///< addrlib handle
768 const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn, ///< [in] per-component value
769 ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) ///< [out] final pixel value
770 {
771 ADDR_E_RETURNCODE returnCode = ADDR_OK;
772
773 Lib* pLib = Lib::GetLib(hLib);
774
775 if (pLib != NULL)
776 {
777 pLib->Flt32ToDepthPixel(pIn, pOut);
778 }
779 else
780 {
781 returnCode = ADDR_ERROR;
782 }
783
784 ADDR_RESET_DEBUG_PRINTERS();
785 return returnCode;
786 }
787
788 /**
789 ****************************************************************************************************
790 * ElemFlt32ToColorPixel
791 *
792 * @brief
793 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
794 *
795 * @return
796 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
797 *
798 ****************************************************************************************************
799 */
ElemFlt32ToColorPixel(ADDR_HANDLE hLib,const ELEM_FLT32TOCOLORPIXEL_INPUT * pIn,ELEM_FLT32TOCOLORPIXEL_OUTPUT * pOut)800 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
801 ADDR_HANDLE hLib, ///< addrlib handle
802 const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn, ///< [in] format, surface number and swap value
803 ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) ///< [out] final pixel value
804 {
805 ADDR_E_RETURNCODE returnCode = ADDR_OK;
806
807 Lib* pLib = Lib::GetLib(hLib);
808
809 if (pLib != NULL)
810 {
811 pLib->Flt32ToColorPixel(pIn, pOut);
812 }
813 else
814 {
815 returnCode = ADDR_ERROR;
816 }
817
818 ADDR_RESET_DEBUG_PRINTERS();
819 return returnCode;
820 }
821
822 /**
823 ****************************************************************************************************
824 * ElemGetExportNorm
825 *
826 * @brief
827 * Helper function to check one format can be EXPORT_NUM,
828 * which is a register CB_COLOR_INFO.SURFACE_FORMAT.
829 * FP16 can be reported as EXPORT_NORM for rv770 in r600
830 * family
831 *
832 ****************************************************************************************************
833 */
ElemGetExportNorm(ADDR_HANDLE hLib,const ELEM_GETEXPORTNORM_INPUT * pIn)834 BOOL_32 ADDR_API ElemGetExportNorm(
835 ADDR_HANDLE hLib, ///< addrlib handle
836 const ELEM_GETEXPORTNORM_INPUT* pIn) ///< [in] input structure
837 {
838 Addr::Lib* pLib = Lib::GetLib(hLib);
839 BOOL_32 enabled = FALSE;
840
841 ADDR_E_RETURNCODE returnCode = ADDR_OK;
842
843 if (pLib != NULL)
844 {
845 enabled = pLib->GetExportNorm(pIn);
846 }
847 else
848 {
849 returnCode = ADDR_ERROR;
850 }
851
852 ADDR_ASSERT(returnCode == ADDR_OK);
853
854 ADDR_RESET_DEBUG_PRINTERS();
855 return enabled;
856 }
857
858 /**
859 ****************************************************************************************************
860 * ElemSize
861 *
862 * @brief
863 * Get bits-per-element for specified format
864 *
865 * @return
866 * Bits-per-element of specified format
867 *
868 ****************************************************************************************************
869 */
ElemSize(ADDR_HANDLE hLib,AddrFormat format)870 UINT_32 ADDR_API ElemSize(
871 ADDR_HANDLE hLib,
872 AddrFormat format)
873 {
874 UINT_32 bpe = 0;
875
876 Addr::Lib* pLib = Lib::GetLib(hLib);
877
878 if (pLib != NULL)
879 {
880 bpe = pLib->GetBpe(format);
881 }
882
883 ADDR_RESET_DEBUG_PRINTERS();
884 return bpe;
885 }
886
887 /**
888 ****************************************************************************************************
889 * AddrConvertTileInfoToHW
890 *
891 * @brief
892 * Convert tile info from real value to hardware register value
893 *
894 * @return
895 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
896 ****************************************************************************************************
897 */
AddrConvertTileInfoToHW(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINFOTOHW_INPUT * pIn,ADDR_CONVERT_TILEINFOTOHW_OUTPUT * pOut)898 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
899 ADDR_HANDLE hLib, ///< address lib handle
900 const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] tile info with real value
901 ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) ///< [out] tile info with HW register value
902 {
903 V1::Lib* pLib = V1::Lib::GetLib(hLib);
904
905 ADDR_E_RETURNCODE returnCode = ADDR_OK;
906
907 if (pLib != NULL)
908 {
909 returnCode = pLib->ConvertTileInfoToHW(pIn, pOut);
910 }
911 else
912 {
913 returnCode = ADDR_ERROR;
914 }
915
916 ADDR_RESET_DEBUG_PRINTERS();
917 return returnCode;
918 }
919
920 /**
921 ****************************************************************************************************
922 * AddrConvertTileIndex
923 *
924 * @brief
925 * Convert tile index to tile mode/type/info
926 *
927 * @return
928 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
929 ****************************************************************************************************
930 */
AddrConvertTileIndex(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINDEX_INPUT * pIn,ADDR_CONVERT_TILEINDEX_OUTPUT * pOut)931 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
932 ADDR_HANDLE hLib, ///< address lib handle
933 const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input - tile index
934 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
935 {
936 V1::Lib* pLib = V1::Lib::GetLib(hLib);
937
938 ADDR_E_RETURNCODE returnCode = ADDR_OK;
939
940 if (pLib != NULL)
941 {
942 returnCode = pLib->ConvertTileIndex(pIn, pOut);
943 }
944 else
945 {
946 returnCode = ADDR_ERROR;
947 }
948
949 ADDR_RESET_DEBUG_PRINTERS();
950 return returnCode;
951 }
952
953 /**
954 ****************************************************************************************************
955 * AddrGetMacroModeIndex
956 *
957 * @brief
958 * Get macro mode index based on input parameters
959 *
960 * @return
961 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
962 ****************************************************************************************************
963 */
AddrGetMacroModeIndex(ADDR_HANDLE hLib,const ADDR_GET_MACROMODEINDEX_INPUT * pIn,ADDR_GET_MACROMODEINDEX_OUTPUT * pOut)964 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
965 ADDR_HANDLE hLib, ///< address lib handle
966 const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input
967 ADDR_GET_MACROMODEINDEX_OUTPUT* pOut) ///< [out] macro mode index
968 {
969 V1::Lib* pLib = V1::Lib::GetLib(hLib);
970
971 ADDR_E_RETURNCODE returnCode;
972
973 if (pLib != NULL)
974 {
975 returnCode = pLib->GetMacroModeIndex(pIn, pOut);
976 }
977 else
978 {
979 returnCode = ADDR_ERROR;
980 }
981
982 ADDR_RESET_DEBUG_PRINTERS();
983 return returnCode;
984 }
985
986 /**
987 ****************************************************************************************************
988 * AddrConvertTileIndex1
989 *
990 * @brief
991 * Convert tile index to tile mode/type/info
992 *
993 * @return
994 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
995 ****************************************************************************************************
996 */
AddrConvertTileIndex1(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINDEX1_INPUT * pIn,ADDR_CONVERT_TILEINDEX_OUTPUT * pOut)997 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
998 ADDR_HANDLE hLib, ///< address lib handle
999 const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input - tile index
1000 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
1001 {
1002 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1003
1004 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1005
1006 if (pLib != NULL)
1007 {
1008 returnCode = pLib->ConvertTileIndex1(pIn, pOut);
1009 }
1010 else
1011 {
1012 returnCode = ADDR_ERROR;
1013 }
1014
1015 ADDR_RESET_DEBUG_PRINTERS();
1016 return returnCode;
1017 }
1018
1019 /**
1020 ****************************************************************************************************
1021 * AddrGetTileIndex
1022 *
1023 * @brief
1024 * Get tile index from tile mode/type/info
1025 *
1026 * @return
1027 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1028 *
1029 * @note
1030 * Only meaningful for SI (and above)
1031 ****************************************************************************************************
1032 */
AddrGetTileIndex(ADDR_HANDLE hLib,const ADDR_GET_TILEINDEX_INPUT * pIn,ADDR_GET_TILEINDEX_OUTPUT * pOut)1033 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
1034 ADDR_HANDLE hLib,
1035 const ADDR_GET_TILEINDEX_INPUT* pIn,
1036 ADDR_GET_TILEINDEX_OUTPUT* pOut)
1037 {
1038 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1039
1040 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1041
1042 if (pLib != NULL)
1043 {
1044 returnCode = pLib->GetTileIndex(pIn, pOut);
1045 }
1046 else
1047 {
1048 returnCode = ADDR_ERROR;
1049 }
1050
1051 ADDR_RESET_DEBUG_PRINTERS();
1052 return returnCode;
1053 }
1054
1055 /**
1056 ****************************************************************************************************
1057 * AddrComputePrtInfo
1058 *
1059 * @brief
1060 * Interface function for ComputePrtInfo
1061 *
1062 ****************************************************************************************************
1063 */
AddrComputePrtInfo(ADDR_HANDLE hLib,const ADDR_PRT_INFO_INPUT * pIn,ADDR_PRT_INFO_OUTPUT * pOut)1064 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
1065 ADDR_HANDLE hLib,
1066 const ADDR_PRT_INFO_INPUT* pIn,
1067 ADDR_PRT_INFO_OUTPUT* pOut)
1068 {
1069 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1070
1071 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1072
1073 if (pLib != NULL)
1074 {
1075 returnCode = pLib->ComputePrtInfo(pIn, pOut);
1076 }
1077 else
1078 {
1079 returnCode = ADDR_ERROR;
1080 }
1081
1082 ADDR_RESET_DEBUG_PRINTERS();
1083 return returnCode;
1084 }
1085
1086 /**
1087 ****************************************************************************************************
1088 * AddrGetMaxAlignments
1089 *
1090 * @brief
1091 * Convert maximum alignments
1092 *
1093 * @return
1094 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1095 ****************************************************************************************************
1096 */
AddrGetMaxAlignments(ADDR_HANDLE hLib,ADDR_GET_MAX_ALIGNMENTS_OUTPUT * pOut)1097 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
1098 ADDR_HANDLE hLib, ///< address lib handle
1099 ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut) ///< [out] output structure
1100 {
1101 Addr::Lib* pLib = Lib::GetLib(hLib);
1102
1103 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1104
1105 if (pLib != NULL)
1106 {
1107 returnCode = pLib->GetMaxAlignments(pOut);
1108 }
1109 else
1110 {
1111 returnCode = ADDR_ERROR;
1112 }
1113
1114 ADDR_RESET_DEBUG_PRINTERS();
1115 return returnCode;
1116 }
1117
1118 /**
1119 ****************************************************************************************************
1120 * AddrGetMaxMetaAlignments
1121 *
1122 * @brief
1123 * Convert maximum alignments for metadata
1124 *
1125 * @return
1126 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1127 ****************************************************************************************************
1128 */
AddrGetMaxMetaAlignments(ADDR_HANDLE hLib,ADDR_GET_MAX_ALIGNMENTS_OUTPUT * pOut)1129 ADDR_E_RETURNCODE ADDR_API AddrGetMaxMetaAlignments(
1130 ADDR_HANDLE hLib, ///< address lib handle
1131 ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut) ///< [out] output structure
1132 {
1133 Addr::Lib* pLib = Lib::GetLib(hLib);
1134
1135 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1136
1137 if (pLib != NULL)
1138 {
1139 returnCode = pLib->GetMaxMetaAlignments(pOut);
1140 }
1141 else
1142 {
1143 returnCode = ADDR_ERROR;
1144 }
1145
1146 ADDR_RESET_DEBUG_PRINTERS();
1147 return returnCode;
1148 }
1149
1150
1151 ////////////////////////////////////////////////////////////////////////////////////////////////////
1152 // Surface functions for Addr2
1153 ////////////////////////////////////////////////////////////////////////////////////////////////////
1154
1155 /**
1156 ****************************************************************************************************
1157 * Addr2ComputeSurfaceInfo
1158 *
1159 * @brief
1160 * Calculate surface width/height/depth/alignments and suitable tiling mode
1161 *
1162 * @return
1163 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1164 ****************************************************************************************************
1165 */
Addr2ComputeSurfaceInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR2_COMPUTE_SURFACE_INFO_OUTPUT * pOut)1166 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceInfo(
1167 ADDR_HANDLE hLib, ///< address lib handle
1168 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
1169 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
1170 {
1171 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1172
1173 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1174
1175 if (pLib != NULL)
1176 {
1177 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
1178 }
1179 else
1180 {
1181 returnCode = ADDR_ERROR;
1182 }
1183
1184 ADDR_RESET_DEBUG_PRINTERS();
1185 return returnCode;
1186 }
1187
1188
1189 /**
1190 ****************************************************************************************************
1191 * Addr2ComputeSurfaceAddrFromCoord
1192 *
1193 * @brief
1194 * Compute surface address according to coordinates
1195 *
1196 * @return
1197 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1198 ****************************************************************************************************
1199 */
Addr2ComputeSurfaceAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)1200 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceAddrFromCoord(
1201 ADDR_HANDLE hLib, ///< address lib handle
1202 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
1203 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
1204 {
1205 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1206
1207 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1208
1209 if (pLib != NULL)
1210 {
1211 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
1212 }
1213 else
1214 {
1215 returnCode = ADDR_ERROR;
1216 }
1217
1218 ADDR_RESET_DEBUG_PRINTERS();
1219 return returnCode;
1220 }
1221
1222
1223 /**
1224 ****************************************************************************************************
1225 * Addr2ComputeSurfaceCoordFromAddr
1226 *
1227 * @brief
1228 * Compute coordinates according to surface address
1229 *
1230 * @return
1231 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1232 ****************************************************************************************************
1233 */
Addr2ComputeSurfaceCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut)1234 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceCoordFromAddr(
1235 ADDR_HANDLE hLib, ///< address lib handle
1236 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address
1237 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates
1238 {
1239 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1240
1241 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1242
1243 if (pLib != NULL)
1244 {
1245 returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
1246 }
1247 else
1248 {
1249 returnCode = ADDR_ERROR;
1250 }
1251
1252 ADDR_RESET_DEBUG_PRINTERS();
1253 return returnCode;
1254 }
1255
1256
1257
1258 ////////////////////////////////////////////////////////////////////////////////////////////////////
1259 // HTile functions for Addr2
1260 ////////////////////////////////////////////////////////////////////////////////////////////////////
1261
1262 /**
1263 ****************************************************************************************************
1264 * Addr2ComputeHtileInfo
1265 *
1266 * @brief
1267 * Compute Htile pitch, height, base alignment and size in bytes
1268 *
1269 * @return
1270 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1271 ****************************************************************************************************
1272 */
Addr2ComputeHtileInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_INFO_INPUT * pIn,ADDR2_COMPUTE_HTILE_INFO_OUTPUT * pOut)1273 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileInfo(
1274 ADDR_HANDLE hLib, ///< address lib handle
1275 const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information
1276 ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes
1277 {
1278 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1279
1280 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1281
1282 if (pLib != NULL)
1283 {
1284 returnCode = pLib->ComputeHtileInfo(pIn, pOut);
1285 }
1286 else
1287 {
1288 returnCode = ADDR_ERROR;
1289 }
1290
1291 ADDR_RESET_DEBUG_PRINTERS();
1292 return returnCode;
1293 }
1294
1295
1296 /**
1297 ****************************************************************************************************
1298 * Addr2ComputeHtileAddrFromCoord
1299 *
1300 * @brief
1301 * Compute Htile address according to coordinates (of depth buffer)
1302 *
1303 * @return
1304 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1305 ****************************************************************************************************
1306 */
Addr2ComputeHtileAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT * pOut)1307 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileAddrFromCoord(
1308 ADDR_HANDLE hLib, ///< address lib handle
1309 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates
1310 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address
1311 {
1312 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1313
1314 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1315
1316 if (pLib != NULL)
1317 {
1318 returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
1319 }
1320 else
1321 {
1322 returnCode = ADDR_ERROR;
1323 }
1324
1325 ADDR_RESET_DEBUG_PRINTERS();
1326 return returnCode;
1327 }
1328
1329
1330 /**
1331 ****************************************************************************************************
1332 * Addr2ComputeHtileCoordFromAddr
1333 *
1334 * @brief
1335 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1336 * Htile address
1337 *
1338 * @return
1339 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1340 ****************************************************************************************************
1341 */
Addr2ComputeHtileCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT * pOut)1342 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileCoordFromAddr(
1343 ADDR_HANDLE hLib, ///< address lib handle
1344 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address
1345 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates
1346 {
1347 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1348
1349 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1350
1351 if (pLib != NULL)
1352 {
1353 returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
1354 }
1355 else
1356 {
1357 returnCode = ADDR_ERROR;
1358 }
1359
1360 ADDR_RESET_DEBUG_PRINTERS();
1361 return returnCode;
1362 }
1363
1364
1365
1366 ////////////////////////////////////////////////////////////////////////////////////////////////////
1367 // C-mask functions for Addr2
1368 ////////////////////////////////////////////////////////////////////////////////////////////////////
1369
1370 /**
1371 ****************************************************************************************************
1372 * Addr2ComputeCmaskInfo
1373 *
1374 * @brief
1375 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1376 * info
1377 *
1378 * @return
1379 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1380 ****************************************************************************************************
1381 */
Addr2ComputeCmaskInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_CMASK_INFO_OUTPUT * pOut)1382 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskInfo(
1383 ADDR_HANDLE hLib, ///< address lib handle
1384 const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height
1385 ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes
1386 {
1387 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1388
1389 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1390
1391 if (pLib != NULL)
1392 {
1393 returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
1394 }
1395 else
1396 {
1397 returnCode = ADDR_ERROR;
1398 }
1399
1400 ADDR_RESET_DEBUG_PRINTERS();
1401 return returnCode;
1402 }
1403
1404
1405 /**
1406 ****************************************************************************************************
1407 * Addr2ComputeCmaskAddrFromCoord
1408 *
1409 * @brief
1410 * Compute Cmask address according to coordinates (of MSAA color buffer)
1411 *
1412 * @return
1413 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1414 ****************************************************************************************************
1415 */
Addr2ComputeCmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT * pOut)1416 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskAddrFromCoord(
1417 ADDR_HANDLE hLib, ///< address lib handle
1418 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates
1419 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address
1420 {
1421 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1422
1423 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1424
1425 if (pLib != NULL)
1426 {
1427 returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
1428 }
1429 else
1430 {
1431 returnCode = ADDR_ERROR;
1432 }
1433
1434 ADDR_RESET_DEBUG_PRINTERS();
1435 return returnCode;
1436 }
1437
1438
1439 /**
1440 ****************************************************************************************************
1441 * Addr2ComputeCmaskCoordFromAddr
1442 *
1443 * @brief
1444 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
1445 * Cmask address
1446 *
1447 * @return
1448 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1449 ****************************************************************************************************
1450 */
Addr2ComputeCmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT * pOut)1451 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskCoordFromAddr(
1452 ADDR_HANDLE hLib, ///< address lib handle
1453 const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address
1454 ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates
1455 {
1456 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1457
1458 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1459
1460 if (pLib != NULL)
1461 {
1462 returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
1463 }
1464 else
1465 {
1466 returnCode = ADDR_ERROR;
1467 }
1468
1469 ADDR_RESET_DEBUG_PRINTERS();
1470 return returnCode;
1471 }
1472
1473
1474
1475 ////////////////////////////////////////////////////////////////////////////////////////////////////
1476 // F-mask functions for Addr2
1477 ////////////////////////////////////////////////////////////////////////////////////////////////////
1478
1479 /**
1480 ****************************************************************************************************
1481 * Addr2ComputeFmaskInfo
1482 *
1483 * @brief
1484 * Compute Fmask pitch/height/depth/alignments and size in bytes
1485 *
1486 * @return
1487 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1488 ****************************************************************************************************
1489 */
Addr2ComputeFmaskInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_FMASK_INFO_OUTPUT * pOut)1490 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskInfo(
1491 ADDR_HANDLE hLib, ///< address lib handle
1492 const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information
1493 ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height
1494 {
1495 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1496
1497 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1498
1499 if (pLib != NULL)
1500 {
1501 returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
1502 }
1503 else
1504 {
1505 returnCode = ADDR_ERROR;
1506 }
1507
1508 ADDR_RESET_DEBUG_PRINTERS();
1509 return returnCode;
1510 }
1511
1512
1513 /**
1514 ****************************************************************************************************
1515 * Addr2ComputeFmaskAddrFromCoord
1516 *
1517 * @brief
1518 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1519 *
1520 * @return
1521 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1522 ****************************************************************************************************
1523 */
Addr2ComputeFmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT * pOut)1524 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskAddrFromCoord(
1525 ADDR_HANDLE hLib, ///< address lib handle
1526 const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates
1527 ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address
1528 {
1529 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1530
1531 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1532
1533 if (pLib != NULL)
1534 {
1535 returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
1536 }
1537 else
1538 {
1539 returnCode = ADDR_ERROR;
1540 }
1541
1542 ADDR_RESET_DEBUG_PRINTERS();
1543 return returnCode;
1544 }
1545
1546
1547 /**
1548 ****************************************************************************************************
1549 * Addr2ComputeFmaskCoordFromAddr
1550 *
1551 * @brief
1552 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
1553 *
1554 * @return
1555 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1556 ****************************************************************************************************
1557 */
Addr2ComputeFmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT * pOut)1558 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskCoordFromAddr(
1559 ADDR_HANDLE hLib, ///< address lib handle
1560 const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address
1561 ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates
1562 {
1563 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1564
1565 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1566
1567 if (pLib != NULL)
1568 {
1569 returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
1570 }
1571 else
1572 {
1573 returnCode = ADDR_ERROR;
1574 }
1575
1576 ADDR_RESET_DEBUG_PRINTERS();
1577 return returnCode;
1578 }
1579
1580
1581
1582 ////////////////////////////////////////////////////////////////////////////////////////////////////
1583 // DCC key functions for Addr2
1584 ////////////////////////////////////////////////////////////////////////////////////////////////////
1585
1586 /**
1587 ****************************************************************************************************
1588 * Addr2ComputeDccInfo
1589 *
1590 * @brief
1591 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
1592 *
1593 ****************************************************************************************************
1594 */
Addr2ComputeDccInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_DCCINFO_INPUT * pIn,ADDR2_COMPUTE_DCCINFO_OUTPUT * pOut)1595 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
1596 ADDR_HANDLE hLib, ///< handle of addrlib
1597 const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input
1598 ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output
1599 {
1600 ADDR_E_RETURNCODE returnCode;
1601
1602 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1603
1604 if (pLib != NULL)
1605 {
1606 returnCode = pLib->ComputeDccInfo(pIn, pOut);
1607 }
1608 else
1609 {
1610 returnCode = ADDR_ERROR;
1611 }
1612
1613 ADDR_RESET_DEBUG_PRINTERS();
1614 return returnCode;
1615 }
1616
1617 /**
1618 ****************************************************************************************************
1619 * Addr2ComputeDccAddrFromCoord
1620 *
1621 * @brief
1622 * Compute DCC key address according to coordinates
1623 *
1624 * @return
1625 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1626 ****************************************************************************************************
1627 */
Addr2ComputeDccAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT * pOut)1628 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
1629 ADDR_HANDLE hLib, ///< address lib handle
1630 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn, ///< [in] Dcc info and coordinates
1631 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Dcc address
1632 {
1633 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1634
1635 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1636
1637 if (pLib != NULL)
1638 {
1639 returnCode = pLib->ComputeDccAddrFromCoord(pIn, pOut);
1640 }
1641 else
1642 {
1643 returnCode = ADDR_ERROR;
1644 }
1645
1646 ADDR_RESET_DEBUG_PRINTERS();
1647 return returnCode;
1648 }
1649
1650 /**
1651 ****************************************************************************************************
1652 * Addr2ComputePipeBankXor
1653 *
1654 * @brief
1655 * Calculate a valid bank pipe xor value for client to use.
1656 ****************************************************************************************************
1657 */
Addr2ComputePipeBankXor(ADDR_HANDLE hLib,const ADDR2_COMPUTE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT * pOut)1658 ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
1659 ADDR_HANDLE hLib, ///< handle of addrlib
1660 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
1661 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
1662 {
1663 ADDR_E_RETURNCODE returnCode;
1664
1665 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1666
1667 if (pLib != NULL)
1668 {
1669 returnCode = pLib->ComputePipeBankXor(pIn, pOut);
1670 }
1671 else
1672 {
1673 returnCode = ADDR_ERROR;
1674 }
1675
1676 ADDR_RESET_DEBUG_PRINTERS();
1677 return returnCode;
1678 }
1679
1680 /**
1681 ****************************************************************************************************
1682 * Addr2ComputeSlicePipeBankXor
1683 *
1684 * @brief
1685 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
1686 ****************************************************************************************************
1687 */
Addr2ComputeSlicePipeBankXor(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT * pOut)1688 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
1689 ADDR_HANDLE hLib, ///< handle of addrlib
1690 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
1691 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
1692 {
1693 ADDR_E_RETURNCODE returnCode;
1694
1695 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1696
1697 if (pLib != NULL)
1698 {
1699 returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
1700 }
1701 else
1702 {
1703 returnCode = ADDR_ERROR;
1704 }
1705
1706 ADDR_RESET_DEBUG_PRINTERS();
1707 return returnCode;
1708 }
1709
1710 /**
1711 ****************************************************************************************************
1712 * Addr2ComputeSubResourceOffsetForSwizzlePattern
1713 *
1714 * @brief
1715 * Calculate sub resource offset for swizzle pattern.
1716 ****************************************************************************************************
1717 */
Addr2ComputeSubResourceOffsetForSwizzlePattern(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT * pIn,ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT * pOut)1718 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
1719 ADDR_HANDLE hLib, ///< handle of addrlib
1720 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, ///< [in] input
1721 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) ///< [out] output
1722 {
1723 ADDR_E_RETURNCODE returnCode;
1724
1725 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1726
1727 if (pLib != NULL)
1728 {
1729 returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
1730 }
1731 else
1732 {
1733 returnCode = ADDR_ERROR;
1734 }
1735
1736 ADDR_RESET_DEBUG_PRINTERS();
1737 return returnCode;
1738 }
1739
1740 /**
1741 ****************************************************************************************************
1742 * Addr2ComputeNonBlockCompressedView
1743 *
1744 * @brief
1745 * Compute non-block-compressed view for a given mipmap level/slice.
1746 ****************************************************************************************************
1747 */
Addr2ComputeNonBlockCompressedView(ADDR_HANDLE hLib,const ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT * pIn,ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT * pOut)1748 ADDR_E_RETURNCODE ADDR_API Addr2ComputeNonBlockCompressedView(
1749 ADDR_HANDLE hLib, ///< handle of addrlib
1750 const ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, ///< [in] input
1751 ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut) ///< [out] output
1752 {
1753 ADDR_E_RETURNCODE returnCode;
1754
1755 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1756
1757 if (pLib != NULL)
1758 {
1759 returnCode = pLib->ComputeNonBlockCompressedView(pIn, pOut);
1760 }
1761 else
1762 {
1763 returnCode = ADDR_ERROR;
1764 }
1765
1766 ADDR_RESET_DEBUG_PRINTERS();
1767 return returnCode;
1768 }
1769
1770 /**
1771 ****************************************************************************************************
1772 * Addr2GetPreferredSurfaceSetting
1773 *
1774 * @brief
1775 * Suggest a preferred setting for client driver to program HW register
1776 ****************************************************************************************************
1777 */
Addr2GetPreferredSurfaceSetting(ADDR_HANDLE hLib,const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT * pIn,ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT * pOut)1778 ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
1779 ADDR_HANDLE hLib, ///< handle of addrlib
1780 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn, ///< [in] input
1781 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) ///< [out] output
1782 {
1783 ADDR_E_RETURNCODE returnCode;
1784
1785 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1786
1787 if (pLib != NULL)
1788 {
1789 returnCode = pLib->Addr2GetPreferredSurfaceSetting(pIn, pOut);
1790 }
1791 else
1792 {
1793 returnCode = ADDR_ERROR;
1794 }
1795
1796 ADDR_RESET_DEBUG_PRINTERS();
1797 return returnCode;
1798 }
1799
1800 /**
1801 ****************************************************************************************************
1802 * Addr2IsValidDisplaySwizzleMode
1803 *
1804 * @brief
1805 * Return whether the swizzle mode is supported by display engine
1806 ****************************************************************************************************
1807 */
Addr2IsValidDisplaySwizzleMode(ADDR_HANDLE hLib,AddrSwizzleMode swizzleMode,UINT_32 bpp,BOOL_32 * pResult)1808 ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
1809 ADDR_HANDLE hLib,
1810 AddrSwizzleMode swizzleMode,
1811 UINT_32 bpp,
1812 BOOL_32 *pResult)
1813 {
1814 ADDR_E_RETURNCODE returnCode;
1815
1816 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1817
1818 if (pLib != NULL)
1819 {
1820 ADDR2_COMPUTE_SURFACE_INFO_INPUT in = {};
1821 in.resourceType = ADDR_RSRC_TEX_2D;
1822 in.swizzleMode = swizzleMode;
1823 in.bpp = bpp;
1824
1825 *pResult = pLib->IsValidDisplaySwizzleMode(&in);
1826 returnCode = ADDR_OK;
1827 }
1828 else
1829 {
1830 returnCode = ADDR_ERROR;
1831 }
1832
1833 ADDR_RESET_DEBUG_PRINTERS();
1834 return returnCode;
1835 }
1836
1837 /**
1838 ****************************************************************************************************
1839 * Addr2GetPossibleSwizzleModes
1840 *
1841 * @brief
1842 * Returns a list of swizzle modes that are valid from the hardware's perspective for the
1843 * client to choose from
1844 ****************************************************************************************************
1845 */
Addr2GetPossibleSwizzleModes(ADDR_HANDLE hLib,const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT * pIn,ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT * pOut)1846 ADDR_E_RETURNCODE ADDR_API Addr2GetPossibleSwizzleModes(
1847 ADDR_HANDLE hLib, ///< handle of addrlib
1848 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn, ///< [in] input
1849 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) ///< [out] output
1850 {
1851 ADDR_E_RETURNCODE returnCode;
1852
1853 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1854
1855 if (pLib != NULL)
1856 {
1857 returnCode = pLib->GetPossibleSwizzleModes(pIn, pOut);
1858 }
1859 else
1860 {
1861 returnCode = ADDR_ERROR;
1862 }
1863
1864 ADDR_RESET_DEBUG_PRINTERS();
1865 return returnCode;
1866 }
1867 /**
1868 ****************************************************************************************************
1869 * Addr2GetAllowedBlockSet
1870 *
1871 * @brief
1872 * Returns the set of allowed block sizes given the allowed swizzle modes and resource type
1873 ****************************************************************************************************
1874 */
Addr2GetAllowedBlockSet(ADDR_HANDLE hLib,ADDR2_SWMODE_SET allowedSwModeSet,AddrResourceType rsrcType,ADDR2_BLOCK_SET * pAllowedBlockSet)1875 ADDR_E_RETURNCODE ADDR_API Addr2GetAllowedBlockSet(
1876 ADDR_HANDLE hLib, ///< handle of addrlib
1877 ADDR2_SWMODE_SET allowedSwModeSet, ///< [in] allowed swizzle modes
1878 AddrResourceType rsrcType, ///< [in] resource type
1879 ADDR2_BLOCK_SET* pAllowedBlockSet) ///< [out] allowed block sizes
1880 {
1881 ADDR_E_RETURNCODE returnCode;
1882
1883 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1884
1885 if (pLib != NULL)
1886 {
1887 returnCode = pLib->GetAllowedBlockSet(allowedSwModeSet, rsrcType, pAllowedBlockSet);
1888 }
1889 else
1890 {
1891 returnCode = ADDR_ERROR;
1892 }
1893
1894 ADDR_RESET_DEBUG_PRINTERS();
1895 return returnCode;
1896 }
1897
1898 /**
1899 ****************************************************************************************************
1900 * Addr2GetAllowedSwSet
1901 *
1902 * @brief
1903 * Returns the set of allowed swizzle types given the allowed swizzle modes
1904 ****************************************************************************************************
1905 */
Addr2GetAllowedSwSet(ADDR_HANDLE hLib,ADDR2_SWMODE_SET allowedSwModeSet,ADDR2_SWTYPE_SET * pAllowedSwSet)1906 ADDR_E_RETURNCODE ADDR_API Addr2GetAllowedSwSet(
1907 ADDR_HANDLE hLib, ///< handle of addrlib
1908 ADDR2_SWMODE_SET allowedSwModeSet, ///< [in] allowed swizzle modes
1909 ADDR2_SWTYPE_SET* pAllowedSwSet) ///< [out] allowed swizzle types
1910 {
1911 ADDR_E_RETURNCODE returnCode;
1912
1913 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1914
1915 if (pLib != NULL)
1916 {
1917 returnCode = pLib->GetAllowedSwSet(allowedSwModeSet, pAllowedSwSet);
1918 }
1919 else
1920 {
1921 returnCode = ADDR_ERROR;
1922 }
1923
1924 ADDR_RESET_DEBUG_PRINTERS();
1925 return returnCode;
1926 }
1927
1928 /**
1929 ****************************************************************************************************
1930 * Addr2IsBlockTypeAvailable
1931 *
1932 * @brief
1933 * Determine whether a block type is allowed in a given blockSet
1934 ****************************************************************************************************
1935 */
Addr2IsBlockTypeAvailable(ADDR2_BLOCK_SET blockSet,AddrBlockType blockType)1936 BOOL_32 Addr2IsBlockTypeAvailable(
1937 ADDR2_BLOCK_SET blockSet,
1938 AddrBlockType blockType)
1939 {
1940 BOOL_32 avail;
1941
1942 if (blockType == AddrBlockLinear)
1943 {
1944 avail = blockSet.linear ? TRUE : FALSE;
1945 }
1946 else
1947 {
1948 avail = blockSet.value & (1 << (static_cast<UINT_32>(blockType) - 1)) ? TRUE : FALSE;
1949 }
1950
1951 ADDR_RESET_DEBUG_PRINTERS();
1952 return avail;
1953 }
1954
1955 /**
1956 ****************************************************************************************************
1957 * Addr2BlockTypeWithinMemoryBudget
1958 *
1959 * @brief
1960 * Determine whether a new block type is acceptable based on memory waste ratio. Will favor
1961 * larger block types.
1962 ****************************************************************************************************
1963 */
Addr2BlockTypeWithinMemoryBudget(UINT_64 minSize,UINT_64 newBlockTypeSize,UINT_32 ratioLow,UINT_32 ratioHi,DOUBLE memoryBudget,BOOL_32 newBlockTypeBigger)1964 BOOL_32 Addr2BlockTypeWithinMemoryBudget(
1965 UINT_64 minSize,
1966 UINT_64 newBlockTypeSize,
1967 UINT_32 ratioLow,
1968 UINT_32 ratioHi,
1969 DOUBLE memoryBudget,
1970 BOOL_32 newBlockTypeBigger)
1971 {
1972 BOOL_32 accept = FALSE;
1973
1974 if (memoryBudget >= 1.0)
1975 {
1976 if (newBlockTypeBigger)
1977 {
1978 if ((static_cast<DOUBLE>(newBlockTypeSize) / minSize) <= memoryBudget)
1979 {
1980 accept = TRUE;
1981 }
1982 }
1983 else
1984 {
1985 if ((static_cast<DOUBLE>(minSize) / newBlockTypeSize) > memoryBudget)
1986 {
1987 accept = TRUE;
1988 }
1989 }
1990 }
1991 else
1992 {
1993 if (newBlockTypeBigger)
1994 {
1995 if ((newBlockTypeSize * ratioHi) <= (minSize * ratioLow))
1996 {
1997 accept = TRUE;
1998 }
1999 }
2000 else
2001 {
2002 if ((newBlockTypeSize * ratioLow) < (minSize * ratioHi))
2003 {
2004 accept = TRUE;
2005 }
2006 }
2007 }
2008
2009 ADDR_RESET_DEBUG_PRINTERS();
2010 return accept;
2011 }
2012
2013 ////////////////////////////////////////////////////////////////////////////////////////////////////
2014 // Surface functions for Addr3
2015 ////////////////////////////////////////////////////////////////////////////////////////////////////
2016
2017 /**
2018 ****************************************************************************************************
2019 * Addr3ComputeSurfaceInfo
2020 *
2021 * @brief
2022 * Calculate surface width/height/depth/alignments and suitable tiling mode
2023 *
2024 * @return
2025 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
2026 ****************************************************************************************************
2027 */
Addr3ComputeSurfaceInfo(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR3_COMPUTE_SURFACE_INFO_OUTPUT * pOut)2028 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSurfaceInfo(
2029 ADDR_HANDLE hLib, ///< address lib handle
2030 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
2031 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
2032 {
2033 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2034
2035 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2036
2037 if (pLib != NULL)
2038 {
2039 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
2040 }
2041
2042 ADDR_RESET_DEBUG_PRINTERS();
2043 return returnCode;
2044 }
2045
2046 /**
2047 ****************************************************************************************************
2048 * Addr3GetPossibleSwizzleModes
2049 *
2050 * @brief
2051 * Get valid swizzle mode options given image input for further optimal selection
2052 *
2053 * @return
2054 * ADDR_OK if successful, otherwise an error code of ADDR_PARAMSIZEMISMATCH
2055 ****************************************************************************************************
2056 */
Addr3GetPossibleSwizzleModes(ADDR_HANDLE hLib,const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT * pIn,ADDR3_GET_POSSIBLE_SWIZZLE_MODE_OUTPUT * pOut)2057 ADDR_E_RETURNCODE ADDR_API Addr3GetPossibleSwizzleModes(
2058 ADDR_HANDLE hLib, ///< address lib handle
2059 const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT* pIn, ///< [in] surface information
2060 ADDR3_GET_POSSIBLE_SWIZZLE_MODE_OUTPUT* pOut) ///< [out] allowable swizzle mdoes
2061 {
2062 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2063
2064 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2065
2066 if (pLib != NULL)
2067 {
2068 returnCode = pLib->GetPossibleSwizzleModes(pIn, pOut);
2069 }
2070
2071 ADDR_RESET_DEBUG_PRINTERS();
2072 return returnCode;
2073 }
2074
2075 /**
2076 ****************************************************************************************************
2077 * Addr3ComputeSurfaceAddrFromCoord
2078 *
2079 * @brief
2080 * Compute surface address according to coordinates
2081 *
2082 * @return
2083 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
2084 ****************************************************************************************************
2085 */
Addr3ComputeSurfaceAddrFromCoord(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)2086 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSurfaceAddrFromCoord(
2087 ADDR_HANDLE hLib, ///< address lib handle
2088 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
2089 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
2090 {
2091 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2092
2093 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2094
2095 if (pLib != NULL)
2096 {
2097 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
2098 }
2099 else
2100 {
2101 returnCode = ADDR_ERROR;
2102 }
2103
2104 ADDR_RESET_DEBUG_PRINTERS();
2105 return returnCode;
2106 }
2107
2108 /**
2109 ****************************************************************************************************
2110 * Addr3ComputePipeBankXor
2111 *
2112 * @brief
2113 * Calculate a valid bank pipe xor value for client to use.
2114 ****************************************************************************************************
2115 */
Addr3ComputePipeBankXor(ADDR_HANDLE hLib,const ADDR3_COMPUTE_PIPEBANKXOR_INPUT * pIn,ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT * pOut)2116 ADDR_E_RETURNCODE ADDR_API Addr3ComputePipeBankXor(
2117 ADDR_HANDLE hLib, ///< handle of addrlib
2118 const ADDR3_COMPUTE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
2119 ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
2120 {
2121 ADDR_E_RETURNCODE returnCode;
2122
2123 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2124
2125 if (pLib != NULL)
2126 {
2127 returnCode = pLib->ComputePipeBankXor(pIn, pOut);
2128 }
2129 else
2130 {
2131 returnCode = ADDR_ERROR;
2132 }
2133
2134 ADDR_RESET_DEBUG_PRINTERS();
2135 return returnCode;
2136 }
2137
2138 /**
2139 ****************************************************************************************************
2140 * Addr3ComputeNonBlockCompressedView
2141 *
2142 * @brief
2143 * Compute non-block-compressed view for a given mipmap level/slice.
2144 ****************************************************************************************************
2145 */
Addr3ComputeNonBlockCompressedView(ADDR_HANDLE hLib,const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT * pIn,ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT * pOut)2146 ADDR_E_RETURNCODE ADDR_API Addr3ComputeNonBlockCompressedView(
2147 ADDR_HANDLE hLib, ///< handle of addrlib
2148 const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, ///< [in] input
2149 ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut) ///< [out] output
2150 {
2151 ADDR_E_RETURNCODE returnCode;
2152
2153 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2154
2155 if (pLib != NULL)
2156 {
2157 returnCode = pLib->ComputeNonBlockCompressedView(pIn, pOut);
2158 }
2159 else
2160 {
2161 returnCode = ADDR_ERROR;
2162 }
2163
2164 ADDR_RESET_DEBUG_PRINTERS();
2165 return returnCode;
2166 }
2167
2168 /**
2169 ****************************************************************************************************
2170 * Addr3ComputeSubResourceOffsetForSwizzlePattern
2171 *
2172 * @brief
2173 * Calculate sub resource offset for swizzle pattern.
2174 ****************************************************************************************************
2175 */
Addr3ComputeSubResourceOffsetForSwizzlePattern(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT * pIn,ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT * pOut)2176 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSubResourceOffsetForSwizzlePattern(
2177 ADDR_HANDLE hLib, ///< handle of addrlib
2178 const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, ///< [in] input
2179 ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) ///< [out] output
2180 {
2181 ADDR_E_RETURNCODE returnCode = ADDR_ERROR;
2182 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2183
2184 if (pLib != NULL)
2185 {
2186 returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
2187 }
2188 ADDR_RESET_DEBUG_PRINTERS();
2189
2190 return returnCode;
2191 }
2192
2193 /**
2194 ****************************************************************************************************
2195 * Addr3ComputeSlicePipeBankXor
2196 *
2197 * @brief
2198 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
2199 ****************************************************************************************************
2200 */
Addr3ComputeSlicePipeBankXor(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT * pIn,ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT * pOut)2201 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSlicePipeBankXor(
2202 ADDR_HANDLE hLib, ///< handle of addrlib
2203 const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
2204 ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
2205 {
2206 ADDR_E_RETURNCODE returnCode;
2207
2208 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2209
2210 if (pLib != NULL)
2211 {
2212 returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
2213 }
2214 else
2215 {
2216 returnCode = ADDR_ERROR;
2217 }
2218
2219 ADDR_RESET_DEBUG_PRINTERS();
2220 return returnCode;
2221 }
2222