1 /*
2 ************************************************************************************************************************
3 *
4 * Copyright (C) 2007-2024 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 * AddrGetInterfaceVersion
579 *
580 * @brief
581 * Get AddrLib interface version number. Client may use this to know what AddrN functions to
582 * use.
583 ****************************************************************************************************
584 */
AddrGetInterfaceVersion(ADDR_HANDLE hLib)585 UINT_32 ADDR_API AddrGetInterfaceVersion(ADDR_HANDLE hLib)
586 {
587 UINT_32 version = 0;
588
589 Addr::Lib* pLib = Lib::GetLib(hLib);
590
591 ADDR_ASSERT(pLib != NULL);
592
593 if (pLib)
594 {
595 version = pLib->GetInterfaceVersion();
596 }
597
598 ADDR_RESET_DEBUG_PRINTERS();
599 return version;
600 }
601
602 /**
603 ****************************************************************************************************
604 * AddrUseTileIndex
605 *
606 * @brief
607 * Return TRUE if tileIndex is enabled in this address library
608 ****************************************************************************************************
609 */
AddrUseTileIndex(ADDR_HANDLE hLib)610 BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib)
611 {
612 BOOL_32 useTileIndex = FALSE;
613
614 V1::Lib* pLib = V1::Lib::GetLib(hLib);
615
616 ADDR_ASSERT(pLib != NULL);
617
618 if (pLib)
619 {
620 useTileIndex = pLib->UseTileIndex(0);
621 }
622
623 ADDR_RESET_DEBUG_PRINTERS();
624 return useTileIndex;
625 }
626
627 /**
628 ****************************************************************************************************
629 * AddrUseCombinedSwizzle
630 *
631 * @brief
632 * Return TRUE if combined swizzle is enabled in this address library
633 ****************************************************************************************************
634 */
AddrUseCombinedSwizzle(ADDR_HANDLE hLib)635 BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib)
636 {
637 BOOL_32 useCombinedSwizzle = FALSE;
638
639 V1::Lib* pLib = V1::Lib::GetLib(hLib);
640
641 ADDR_ASSERT(pLib != NULL);
642
643 if (pLib)
644 {
645 useCombinedSwizzle = pLib->UseCombinedSwizzle();
646 }
647
648 ADDR_RESET_DEBUG_PRINTERS();
649 return useCombinedSwizzle;
650 }
651
652 /**
653 ****************************************************************************************************
654 * AddrExtractBankPipeSwizzle
655 *
656 * @brief
657 * Extract Bank and Pipe swizzle from base256b
658 * @return
659 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
660 ****************************************************************************************************
661 */
AddrExtractBankPipeSwizzle(ADDR_HANDLE hLib,const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT * pIn,ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT * pOut)662 ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
663 ADDR_HANDLE hLib, ///< addrlib handle
664 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure
665 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) ///< [out] output structure
666 {
667 ADDR_E_RETURNCODE returnCode = ADDR_OK;
668
669 V1::Lib* pLib = V1::Lib::GetLib(hLib);
670
671 if (pLib != NULL)
672 {
673 returnCode = pLib->ExtractBankPipeSwizzle(pIn, pOut);
674 }
675 else
676 {
677 returnCode = ADDR_ERROR;
678 }
679
680 ADDR_RESET_DEBUG_PRINTERS();
681 return returnCode;
682 }
683
684 /**
685 ****************************************************************************************************
686 * AddrCombineBankPipeSwizzle
687 *
688 * @brief
689 * Combine Bank and Pipe swizzle
690 * @return
691 * ADDR_E_RETURNCODE
692 ****************************************************************************************************
693 */
AddrCombineBankPipeSwizzle(ADDR_HANDLE hLib,const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT * pIn,ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT * pOut)694 ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
695 ADDR_HANDLE hLib,
696 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn,
697 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut)
698 {
699 ADDR_E_RETURNCODE returnCode = ADDR_OK;
700
701 V1::Lib* pLib = V1::Lib::GetLib(hLib);
702
703 if (pLib != NULL)
704 {
705 returnCode = pLib->CombineBankPipeSwizzle(pIn, pOut);
706 }
707 else
708 {
709 returnCode = ADDR_ERROR;
710 }
711
712 ADDR_RESET_DEBUG_PRINTERS();
713 return returnCode;
714 }
715
716 /**
717 ****************************************************************************************************
718 * AddrComputeSliceSwizzle
719 *
720 * @brief
721 * Compute a swizzle for slice from a base swizzle
722 * @return
723 * ADDR_OK if no error
724 ****************************************************************************************************
725 */
AddrComputeSliceSwizzle(ADDR_HANDLE hLib,const ADDR_COMPUTE_SLICESWIZZLE_INPUT * pIn,ADDR_COMPUTE_SLICESWIZZLE_OUTPUT * pOut)726 ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
727 ADDR_HANDLE hLib,
728 const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn,
729 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut)
730 {
731 ADDR_E_RETURNCODE returnCode = ADDR_OK;
732
733 V1::Lib* pLib = V1::Lib::GetLib(hLib);
734
735 if (pLib != NULL)
736 {
737 returnCode = pLib->ComputeSliceTileSwizzle(pIn, pOut);
738 }
739 else
740 {
741 returnCode = ADDR_ERROR;
742 }
743
744 ADDR_RESET_DEBUG_PRINTERS();
745 return returnCode;
746 }
747
748 /**
749 ****************************************************************************************************
750 * AddrComputeBaseSwizzle
751 *
752 * @brief
753 * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
754 * @return
755 * ADDR_OK if no error
756 ****************************************************************************************************
757 */
AddrComputeBaseSwizzle(ADDR_HANDLE hLib,const ADDR_COMPUTE_BASE_SWIZZLE_INPUT * pIn,ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT * pOut)758 ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
759 ADDR_HANDLE hLib,
760 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
761 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut)
762 {
763 ADDR_E_RETURNCODE returnCode = ADDR_OK;
764
765 V1::Lib* pLib = V1::Lib::GetLib(hLib);
766
767 if (pLib != NULL)
768 {
769 returnCode = pLib->ComputeBaseSwizzle(pIn, pOut);
770 }
771 else
772 {
773 returnCode = ADDR_ERROR;
774 }
775
776 ADDR_RESET_DEBUG_PRINTERS();
777 return returnCode;
778 }
779
780 /**
781 ****************************************************************************************************
782 * ElemFlt32ToDepthPixel
783 *
784 * @brief
785 * Convert a FLT_32 value to a depth/stencil pixel value
786 *
787 * @return
788 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
789 *
790 ****************************************************************************************************
791 */
ElemFlt32ToDepthPixel(ADDR_HANDLE hLib,const ELEM_FLT32TODEPTHPIXEL_INPUT * pIn,ELEM_FLT32TODEPTHPIXEL_OUTPUT * pOut)792 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
793 ADDR_HANDLE hLib, ///< addrlib handle
794 const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn, ///< [in] per-component value
795 ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) ///< [out] final pixel value
796 {
797 ADDR_E_RETURNCODE returnCode = ADDR_OK;
798
799 Lib* pLib = Lib::GetLib(hLib);
800
801 if (pLib != NULL)
802 {
803 pLib->Flt32ToDepthPixel(pIn, pOut);
804 }
805 else
806 {
807 returnCode = ADDR_ERROR;
808 }
809
810 ADDR_RESET_DEBUG_PRINTERS();
811 return returnCode;
812 }
813
814 /**
815 ****************************************************************************************************
816 * ElemFlt32ToColorPixel
817 *
818 * @brief
819 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
820 *
821 * @return
822 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
823 *
824 ****************************************************************************************************
825 */
ElemFlt32ToColorPixel(ADDR_HANDLE hLib,const ELEM_FLT32TOCOLORPIXEL_INPUT * pIn,ELEM_FLT32TOCOLORPIXEL_OUTPUT * pOut)826 ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
827 ADDR_HANDLE hLib, ///< addrlib handle
828 const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn, ///< [in] format, surface number and swap value
829 ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) ///< [out] final pixel value
830 {
831 ADDR_E_RETURNCODE returnCode = ADDR_OK;
832
833 Lib* pLib = Lib::GetLib(hLib);
834
835 if (pLib != NULL)
836 {
837 pLib->Flt32ToColorPixel(pIn, pOut);
838 }
839 else
840 {
841 returnCode = ADDR_ERROR;
842 }
843
844 ADDR_RESET_DEBUG_PRINTERS();
845 return returnCode;
846 }
847
848 /**
849 ****************************************************************************************************
850 * ElemGetExportNorm
851 *
852 * @brief
853 * Helper function to check one format can be EXPORT_NUM,
854 * which is a register CB_COLOR_INFO.SURFACE_FORMAT.
855 * FP16 can be reported as EXPORT_NORM for rv770 in r600
856 * family
857 *
858 ****************************************************************************************************
859 */
ElemGetExportNorm(ADDR_HANDLE hLib,const ELEM_GETEXPORTNORM_INPUT * pIn)860 BOOL_32 ADDR_API ElemGetExportNorm(
861 ADDR_HANDLE hLib, ///< addrlib handle
862 const ELEM_GETEXPORTNORM_INPUT* pIn) ///< [in] input structure
863 {
864 Addr::Lib* pLib = Lib::GetLib(hLib);
865 BOOL_32 enabled = FALSE;
866
867 ADDR_E_RETURNCODE returnCode = ADDR_OK;
868
869 if (pLib != NULL)
870 {
871 enabled = pLib->GetExportNorm(pIn);
872 }
873 else
874 {
875 returnCode = ADDR_ERROR;
876 }
877
878 ADDR_ASSERT(returnCode == ADDR_OK);
879
880 ADDR_RESET_DEBUG_PRINTERS();
881 return enabled;
882 }
883
884 /**
885 ****************************************************************************************************
886 * ElemSize
887 *
888 * @brief
889 * Get bits-per-element for specified format
890 *
891 * @return
892 * Bits-per-element of specified format
893 *
894 ****************************************************************************************************
895 */
ElemSize(ADDR_HANDLE hLib,AddrFormat format)896 UINT_32 ADDR_API ElemSize(
897 ADDR_HANDLE hLib,
898 AddrFormat format)
899 {
900 UINT_32 bpe = 0;
901
902 Addr::Lib* pLib = Lib::GetLib(hLib);
903
904 if (pLib != NULL)
905 {
906 bpe = pLib->GetBpe(format);
907 }
908
909 ADDR_RESET_DEBUG_PRINTERS();
910 return bpe;
911 }
912
913 /**
914 ****************************************************************************************************
915 * AddrConvertTileInfoToHW
916 *
917 * @brief
918 * Convert tile info from real value to hardware register value
919 *
920 * @return
921 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
922 ****************************************************************************************************
923 */
AddrConvertTileInfoToHW(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINFOTOHW_INPUT * pIn,ADDR_CONVERT_TILEINFOTOHW_OUTPUT * pOut)924 ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
925 ADDR_HANDLE hLib, ///< address lib handle
926 const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] tile info with real value
927 ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) ///< [out] tile info with HW register value
928 {
929 V1::Lib* pLib = V1::Lib::GetLib(hLib);
930
931 ADDR_E_RETURNCODE returnCode = ADDR_OK;
932
933 if (pLib != NULL)
934 {
935 returnCode = pLib->ConvertTileInfoToHW(pIn, pOut);
936 }
937 else
938 {
939 returnCode = ADDR_ERROR;
940 }
941
942 ADDR_RESET_DEBUG_PRINTERS();
943 return returnCode;
944 }
945
946 /**
947 ****************************************************************************************************
948 * AddrConvertTileIndex
949 *
950 * @brief
951 * Convert tile index to tile mode/type/info
952 *
953 * @return
954 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
955 ****************************************************************************************************
956 */
AddrConvertTileIndex(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINDEX_INPUT * pIn,ADDR_CONVERT_TILEINDEX_OUTPUT * pOut)957 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
958 ADDR_HANDLE hLib, ///< address lib handle
959 const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input - tile index
960 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
961 {
962 V1::Lib* pLib = V1::Lib::GetLib(hLib);
963
964 ADDR_E_RETURNCODE returnCode = ADDR_OK;
965
966 if (pLib != NULL)
967 {
968 returnCode = pLib->ConvertTileIndex(pIn, pOut);
969 }
970 else
971 {
972 returnCode = ADDR_ERROR;
973 }
974
975 ADDR_RESET_DEBUG_PRINTERS();
976 return returnCode;
977 }
978
979 /**
980 ****************************************************************************************************
981 * AddrGetMacroModeIndex
982 *
983 * @brief
984 * Get macro mode index based on input parameters
985 *
986 * @return
987 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
988 ****************************************************************************************************
989 */
AddrGetMacroModeIndex(ADDR_HANDLE hLib,const ADDR_GET_MACROMODEINDEX_INPUT * pIn,ADDR_GET_MACROMODEINDEX_OUTPUT * pOut)990 ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
991 ADDR_HANDLE hLib, ///< address lib handle
992 const ADDR_GET_MACROMODEINDEX_INPUT* pIn, ///< [in] input
993 ADDR_GET_MACROMODEINDEX_OUTPUT* pOut) ///< [out] macro mode index
994 {
995 V1::Lib* pLib = V1::Lib::GetLib(hLib);
996
997 ADDR_E_RETURNCODE returnCode;
998
999 if (pLib != NULL)
1000 {
1001 returnCode = pLib->GetMacroModeIndex(pIn, pOut);
1002 }
1003 else
1004 {
1005 returnCode = ADDR_ERROR;
1006 }
1007
1008 ADDR_RESET_DEBUG_PRINTERS();
1009 return returnCode;
1010 }
1011
1012 /**
1013 ****************************************************************************************************
1014 * AddrConvertTileIndex1
1015 *
1016 * @brief
1017 * Convert tile index to tile mode/type/info
1018 *
1019 * @return
1020 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1021 ****************************************************************************************************
1022 */
AddrConvertTileIndex1(ADDR_HANDLE hLib,const ADDR_CONVERT_TILEINDEX1_INPUT * pIn,ADDR_CONVERT_TILEINDEX_OUTPUT * pOut)1023 ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
1024 ADDR_HANDLE hLib, ///< address lib handle
1025 const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input - tile index
1026 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info
1027 {
1028 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1029
1030 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1031
1032 if (pLib != NULL)
1033 {
1034 returnCode = pLib->ConvertTileIndex1(pIn, pOut);
1035 }
1036 else
1037 {
1038 returnCode = ADDR_ERROR;
1039 }
1040
1041 ADDR_RESET_DEBUG_PRINTERS();
1042 return returnCode;
1043 }
1044
1045 /**
1046 ****************************************************************************************************
1047 * AddrGetTileIndex
1048 *
1049 * @brief
1050 * Get tile index from tile mode/type/info
1051 *
1052 * @return
1053 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1054 *
1055 * @note
1056 * Only meaningful for SI (and above)
1057 ****************************************************************************************************
1058 */
AddrGetTileIndex(ADDR_HANDLE hLib,const ADDR_GET_TILEINDEX_INPUT * pIn,ADDR_GET_TILEINDEX_OUTPUT * pOut)1059 ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
1060 ADDR_HANDLE hLib,
1061 const ADDR_GET_TILEINDEX_INPUT* pIn,
1062 ADDR_GET_TILEINDEX_OUTPUT* pOut)
1063 {
1064 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1065
1066 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1067
1068 if (pLib != NULL)
1069 {
1070 returnCode = pLib->GetTileIndex(pIn, pOut);
1071 }
1072 else
1073 {
1074 returnCode = ADDR_ERROR;
1075 }
1076
1077 ADDR_RESET_DEBUG_PRINTERS();
1078 return returnCode;
1079 }
1080
1081 /**
1082 ****************************************************************************************************
1083 * AddrComputePrtInfo
1084 *
1085 * @brief
1086 * Interface function for ComputePrtInfo
1087 *
1088 ****************************************************************************************************
1089 */
AddrComputePrtInfo(ADDR_HANDLE hLib,const ADDR_PRT_INFO_INPUT * pIn,ADDR_PRT_INFO_OUTPUT * pOut)1090 ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
1091 ADDR_HANDLE hLib,
1092 const ADDR_PRT_INFO_INPUT* pIn,
1093 ADDR_PRT_INFO_OUTPUT* pOut)
1094 {
1095 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1096
1097 V1::Lib* pLib = V1::Lib::GetLib(hLib);
1098
1099 if (pLib != NULL)
1100 {
1101 returnCode = pLib->ComputePrtInfo(pIn, pOut);
1102 }
1103 else
1104 {
1105 returnCode = ADDR_ERROR;
1106 }
1107
1108 ADDR_RESET_DEBUG_PRINTERS();
1109 return returnCode;
1110 }
1111
1112 /**
1113 ****************************************************************************************************
1114 * AddrGetMaxAlignments
1115 *
1116 * @brief
1117 * Convert maximum alignments
1118 *
1119 * @return
1120 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1121 ****************************************************************************************************
1122 */
AddrGetMaxAlignments(ADDR_HANDLE hLib,ADDR_GET_MAX_ALIGNMENTS_OUTPUT * pOut)1123 ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
1124 ADDR_HANDLE hLib, ///< address lib handle
1125 ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut) ///< [out] output structure
1126 {
1127 Addr::Lib* pLib = Lib::GetLib(hLib);
1128
1129 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1130
1131 if (pLib != NULL)
1132 {
1133 returnCode = pLib->GetMaxAlignments(pOut);
1134 }
1135 else
1136 {
1137 returnCode = ADDR_ERROR;
1138 }
1139
1140 ADDR_RESET_DEBUG_PRINTERS();
1141 return returnCode;
1142 }
1143
1144 /**
1145 ****************************************************************************************************
1146 * AddrGetMaxMetaAlignments
1147 *
1148 * @brief
1149 * Convert maximum alignments for metadata
1150 *
1151 * @return
1152 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1153 ****************************************************************************************************
1154 */
AddrGetMaxMetaAlignments(ADDR_HANDLE hLib,ADDR_GET_MAX_ALIGNMENTS_OUTPUT * pOut)1155 ADDR_E_RETURNCODE ADDR_API AddrGetMaxMetaAlignments(
1156 ADDR_HANDLE hLib, ///< address lib handle
1157 ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut) ///< [out] output structure
1158 {
1159 Addr::Lib* pLib = Lib::GetLib(hLib);
1160
1161 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1162
1163 if (pLib != NULL)
1164 {
1165 returnCode = pLib->GetMaxMetaAlignments(pOut);
1166 }
1167 else
1168 {
1169 returnCode = ADDR_ERROR;
1170 }
1171
1172 ADDR_RESET_DEBUG_PRINTERS();
1173 return returnCode;
1174 }
1175
1176
1177 ////////////////////////////////////////////////////////////////////////////////////////////////////
1178 // Surface functions for Addr2
1179 ////////////////////////////////////////////////////////////////////////////////////////////////////
1180
1181 /**
1182 ****************************************************************************************************
1183 * Addr2ComputeSurfaceInfo
1184 *
1185 * @brief
1186 * Calculate surface width/height/depth/alignments and suitable tiling mode
1187 *
1188 * @return
1189 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1190 ****************************************************************************************************
1191 */
Addr2ComputeSurfaceInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR2_COMPUTE_SURFACE_INFO_OUTPUT * pOut)1192 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceInfo(
1193 ADDR_HANDLE hLib, ///< address lib handle
1194 const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
1195 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
1196 {
1197 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1198
1199 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1200
1201 if (pLib != NULL)
1202 {
1203 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
1204 }
1205 else
1206 {
1207 returnCode = ADDR_ERROR;
1208 }
1209
1210 ADDR_RESET_DEBUG_PRINTERS();
1211 return returnCode;
1212 }
1213
1214
1215 /**
1216 ****************************************************************************************************
1217 * Addr2ComputeSurfaceAddrFromCoord
1218 *
1219 * @brief
1220 * Compute surface address according to coordinates
1221 *
1222 * @return
1223 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1224 ****************************************************************************************************
1225 */
Addr2ComputeSurfaceAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)1226 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceAddrFromCoord(
1227 ADDR_HANDLE hLib, ///< address lib handle
1228 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
1229 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
1230 {
1231 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1232
1233 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1234
1235 if (pLib != NULL)
1236 {
1237 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
1238 }
1239 else
1240 {
1241 returnCode = ADDR_ERROR;
1242 }
1243
1244 ADDR_RESET_DEBUG_PRINTERS();
1245 return returnCode;
1246 }
1247
1248 /**
1249 ****************************************************************************************************
1250 * Addr2CopyMemToSurface
1251 *
1252 * @brief
1253 * Copy an image region from memory to an uncompressed CPU-mapped surface
1254 *
1255 * @return
1256 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1257 ****************************************************************************************************
1258 */
Addr2CopyMemToSurface(ADDR_HANDLE hLib,const ADDR2_COPY_MEMSURFACE_INPUT * pIn,const ADDR2_COPY_MEMSURFACE_REGION * pRegions,UINT_32 regionCount)1259 ADDR_E_RETURNCODE ADDR_API Addr2CopyMemToSurface(
1260 ADDR_HANDLE hLib, ///< address lib handle
1261 const ADDR2_COPY_MEMSURFACE_INPUT* pIn, ///< [in] description of image and mapping
1262 const ADDR2_COPY_MEMSURFACE_REGION* pRegions, ///< [in] list of copy regions
1263 UINT_32 regionCount) ///< [in] count of copy regions in list
1264 {
1265 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1266
1267 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1268
1269 if (pLib != NULL)
1270 {
1271 returnCode = pLib->CopyMemToSurface(pIn, pRegions, regionCount);
1272 }
1273 else
1274 {
1275 returnCode = ADDR_ERROR;
1276 }
1277
1278 return returnCode;
1279 }
1280
1281 /**
1282 ****************************************************************************************************
1283 * Addr2CopySurfaceToMem
1284 *
1285 * @brief
1286 * Copy an image region from an uncompressed CPU-mapped surface to memory
1287 *
1288 * @return
1289 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1290 ****************************************************************************************************
1291 */
Addr2CopySurfaceToMem(ADDR_HANDLE hLib,const ADDR2_COPY_MEMSURFACE_INPUT * pIn,const ADDR2_COPY_MEMSURFACE_REGION * pRegions,UINT_32 regionCount)1292 ADDR_E_RETURNCODE ADDR_API Addr2CopySurfaceToMem(
1293 ADDR_HANDLE hLib, ///< address lib handle
1294 const ADDR2_COPY_MEMSURFACE_INPUT* pIn, ///< [in] description of image and mapping
1295 const ADDR2_COPY_MEMSURFACE_REGION* pRegions, ///< [in] list of copy regions
1296 UINT_32 regionCount) ///< [in] count of copy regions in list
1297 {
1298 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1299
1300 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1301
1302 if (pLib != NULL)
1303 {
1304 returnCode = pLib->CopySurfaceToMem(pIn, pRegions, regionCount);
1305 }
1306 else
1307 {
1308 returnCode = ADDR_ERROR;
1309 }
1310
1311 return returnCode;
1312 }
1313
1314
1315 /**
1316 ****************************************************************************************************
1317 * Addr2ComputeSurfaceCoordFromAddr
1318 *
1319 * @brief
1320 * Compute coordinates according to surface address
1321 *
1322 * @return
1323 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1324 ****************************************************************************************************
1325 */
Addr2ComputeSurfaceCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT * pOut)1326 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceCoordFromAddr(
1327 ADDR_HANDLE hLib, ///< address lib handle
1328 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address
1329 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates
1330 {
1331 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1332
1333 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1334
1335 if (pLib != NULL)
1336 {
1337 returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
1338 }
1339 else
1340 {
1341 returnCode = ADDR_ERROR;
1342 }
1343
1344 ADDR_RESET_DEBUG_PRINTERS();
1345 return returnCode;
1346 }
1347
1348
1349
1350 ////////////////////////////////////////////////////////////////////////////////////////////////////
1351 // HTile functions for Addr2
1352 ////////////////////////////////////////////////////////////////////////////////////////////////////
1353
1354 /**
1355 ****************************************************************************************************
1356 * Addr2ComputeHtileInfo
1357 *
1358 * @brief
1359 * Compute Htile pitch, height, base alignment and size in bytes
1360 *
1361 * @return
1362 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1363 ****************************************************************************************************
1364 */
Addr2ComputeHtileInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_INFO_INPUT * pIn,ADDR2_COMPUTE_HTILE_INFO_OUTPUT * pOut)1365 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileInfo(
1366 ADDR_HANDLE hLib, ///< address lib handle
1367 const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information
1368 ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes
1369 {
1370 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1371
1372 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1373
1374 if (pLib != NULL)
1375 {
1376 returnCode = pLib->ComputeHtileInfo(pIn, pOut);
1377 }
1378 else
1379 {
1380 returnCode = ADDR_ERROR;
1381 }
1382
1383 ADDR_RESET_DEBUG_PRINTERS();
1384 return returnCode;
1385 }
1386
1387
1388 /**
1389 ****************************************************************************************************
1390 * Addr2ComputeHtileAddrFromCoord
1391 *
1392 * @brief
1393 * Compute Htile address according to coordinates (of depth buffer)
1394 *
1395 * @return
1396 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1397 ****************************************************************************************************
1398 */
Addr2ComputeHtileAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT * pOut)1399 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileAddrFromCoord(
1400 ADDR_HANDLE hLib, ///< address lib handle
1401 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates
1402 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address
1403 {
1404 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1405
1406 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1407
1408 if (pLib != NULL)
1409 {
1410 returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
1411 }
1412 else
1413 {
1414 returnCode = ADDR_ERROR;
1415 }
1416
1417 ADDR_RESET_DEBUG_PRINTERS();
1418 return returnCode;
1419 }
1420
1421
1422 /**
1423 ****************************************************************************************************
1424 * Addr2ComputeHtileCoordFromAddr
1425 *
1426 * @brief
1427 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1428 * Htile address
1429 *
1430 * @return
1431 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1432 ****************************************************************************************************
1433 */
Addr2ComputeHtileCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT * pOut)1434 ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileCoordFromAddr(
1435 ADDR_HANDLE hLib, ///< address lib handle
1436 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address
1437 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates
1438 {
1439 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1440
1441 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1442
1443 if (pLib != NULL)
1444 {
1445 returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
1446 }
1447 else
1448 {
1449 returnCode = ADDR_ERROR;
1450 }
1451
1452 ADDR_RESET_DEBUG_PRINTERS();
1453 return returnCode;
1454 }
1455
1456
1457
1458 ////////////////////////////////////////////////////////////////////////////////////////////////////
1459 // C-mask functions for Addr2
1460 ////////////////////////////////////////////////////////////////////////////////////////////////////
1461
1462 /**
1463 ****************************************************************************************************
1464 * Addr2ComputeCmaskInfo
1465 *
1466 * @brief
1467 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1468 * info
1469 *
1470 * @return
1471 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1472 ****************************************************************************************************
1473 */
Addr2ComputeCmaskInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_CMASK_INFO_OUTPUT * pOut)1474 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskInfo(
1475 ADDR_HANDLE hLib, ///< address lib handle
1476 const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height
1477 ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes
1478 {
1479 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1480
1481 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1482
1483 if (pLib != NULL)
1484 {
1485 returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
1486 }
1487 else
1488 {
1489 returnCode = ADDR_ERROR;
1490 }
1491
1492 ADDR_RESET_DEBUG_PRINTERS();
1493 return returnCode;
1494 }
1495
1496
1497 /**
1498 ****************************************************************************************************
1499 * Addr2ComputeCmaskAddrFromCoord
1500 *
1501 * @brief
1502 * Compute Cmask address according to coordinates (of MSAA color buffer)
1503 *
1504 * @return
1505 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1506 ****************************************************************************************************
1507 */
Addr2ComputeCmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT * pOut)1508 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskAddrFromCoord(
1509 ADDR_HANDLE hLib, ///< address lib handle
1510 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates
1511 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address
1512 {
1513 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1514
1515 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1516
1517 if (pLib != NULL)
1518 {
1519 returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
1520 }
1521 else
1522 {
1523 returnCode = ADDR_ERROR;
1524 }
1525
1526 ADDR_RESET_DEBUG_PRINTERS();
1527 return returnCode;
1528 }
1529
1530
1531 /**
1532 ****************************************************************************************************
1533 * Addr2ComputeCmaskCoordFromAddr
1534 *
1535 * @brief
1536 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
1537 * Cmask address
1538 *
1539 * @return
1540 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1541 ****************************************************************************************************
1542 */
Addr2ComputeCmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT * pOut)1543 ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskCoordFromAddr(
1544 ADDR_HANDLE hLib, ///< address lib handle
1545 const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address
1546 ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates
1547 {
1548 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1549
1550 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1551
1552 if (pLib != NULL)
1553 {
1554 returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
1555 }
1556 else
1557 {
1558 returnCode = ADDR_ERROR;
1559 }
1560
1561 ADDR_RESET_DEBUG_PRINTERS();
1562 return returnCode;
1563 }
1564
1565
1566
1567 ////////////////////////////////////////////////////////////////////////////////////////////////////
1568 // F-mask functions for Addr2
1569 ////////////////////////////////////////////////////////////////////////////////////////////////////
1570
1571 /**
1572 ****************************************************************************************************
1573 * Addr2ComputeFmaskInfo
1574 *
1575 * @brief
1576 * Compute Fmask pitch/height/depth/alignments and size in bytes
1577 *
1578 * @return
1579 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1580 ****************************************************************************************************
1581 */
Addr2ComputeFmaskInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_INFO_INPUT * pIn,ADDR2_COMPUTE_FMASK_INFO_OUTPUT * pOut)1582 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskInfo(
1583 ADDR_HANDLE hLib, ///< address lib handle
1584 const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information
1585 ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height
1586 {
1587 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1588
1589 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1590
1591 if (pLib != NULL)
1592 {
1593 returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
1594 }
1595 else
1596 {
1597 returnCode = ADDR_ERROR;
1598 }
1599
1600 ADDR_RESET_DEBUG_PRINTERS();
1601 return returnCode;
1602 }
1603
1604
1605 /**
1606 ****************************************************************************************************
1607 * Addr2ComputeFmaskAddrFromCoord
1608 *
1609 * @brief
1610 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1611 *
1612 * @return
1613 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1614 ****************************************************************************************************
1615 */
Addr2ComputeFmaskAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT * pOut)1616 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskAddrFromCoord(
1617 ADDR_HANDLE hLib, ///< address lib handle
1618 const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates
1619 ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address
1620 {
1621 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1622
1623 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1624
1625 if (pLib != NULL)
1626 {
1627 returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
1628 }
1629 else
1630 {
1631 returnCode = ADDR_ERROR;
1632 }
1633
1634 ADDR_RESET_DEBUG_PRINTERS();
1635 return returnCode;
1636 }
1637
1638
1639 /**
1640 ****************************************************************************************************
1641 * Addr2ComputeFmaskCoordFromAddr
1642 *
1643 * @brief
1644 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
1645 *
1646 * @return
1647 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1648 ****************************************************************************************************
1649 */
Addr2ComputeFmaskCoordFromAddr(ADDR_HANDLE hLib,const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT * pIn,ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT * pOut)1650 ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskCoordFromAddr(
1651 ADDR_HANDLE hLib, ///< address lib handle
1652 const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address
1653 ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates
1654 {
1655 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1656
1657 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1658
1659 if (pLib != NULL)
1660 {
1661 returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
1662 }
1663 else
1664 {
1665 returnCode = ADDR_ERROR;
1666 }
1667
1668 ADDR_RESET_DEBUG_PRINTERS();
1669 return returnCode;
1670 }
1671
1672
1673
1674 ////////////////////////////////////////////////////////////////////////////////////////////////////
1675 // DCC key functions for Addr2
1676 ////////////////////////////////////////////////////////////////////////////////////////////////////
1677
1678 /**
1679 ****************************************************************************************************
1680 * Addr2ComputeDccInfo
1681 *
1682 * @brief
1683 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
1684 *
1685 ****************************************************************************************************
1686 */
Addr2ComputeDccInfo(ADDR_HANDLE hLib,const ADDR2_COMPUTE_DCCINFO_INPUT * pIn,ADDR2_COMPUTE_DCCINFO_OUTPUT * pOut)1687 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
1688 ADDR_HANDLE hLib, ///< handle of addrlib
1689 const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input
1690 ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output
1691 {
1692 ADDR_E_RETURNCODE returnCode;
1693
1694 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1695
1696 if (pLib != NULL)
1697 {
1698 returnCode = pLib->ComputeDccInfo(pIn, pOut);
1699 }
1700 else
1701 {
1702 returnCode = ADDR_ERROR;
1703 }
1704
1705 ADDR_RESET_DEBUG_PRINTERS();
1706 return returnCode;
1707 }
1708
1709 /**
1710 ****************************************************************************************************
1711 * Addr2ComputeDccAddrFromCoord
1712 *
1713 * @brief
1714 * Compute DCC key address according to coordinates
1715 *
1716 * @return
1717 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1718 ****************************************************************************************************
1719 */
Addr2ComputeDccAddrFromCoord(ADDR_HANDLE hLib,const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT * pIn,ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT * pOut)1720 ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
1721 ADDR_HANDLE hLib, ///< address lib handle
1722 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn, ///< [in] Dcc info and coordinates
1723 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Dcc address
1724 {
1725 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1726
1727 ADDR_E_RETURNCODE returnCode = ADDR_OK;
1728
1729 if (pLib != NULL)
1730 {
1731 returnCode = pLib->ComputeDccAddrFromCoord(pIn, pOut);
1732 }
1733 else
1734 {
1735 returnCode = ADDR_ERROR;
1736 }
1737
1738 ADDR_RESET_DEBUG_PRINTERS();
1739 return returnCode;
1740 }
1741
1742 /**
1743 ****************************************************************************************************
1744 * Addr2ComputePipeBankXor
1745 *
1746 * @brief
1747 * Calculate a valid bank pipe xor value for client to use.
1748 ****************************************************************************************************
1749 */
Addr2ComputePipeBankXor(ADDR_HANDLE hLib,const ADDR2_COMPUTE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT * pOut)1750 ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
1751 ADDR_HANDLE hLib, ///< handle of addrlib
1752 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
1753 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
1754 {
1755 ADDR_E_RETURNCODE returnCode;
1756
1757 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1758
1759 if (pLib != NULL)
1760 {
1761 returnCode = pLib->ComputePipeBankXor(pIn, pOut);
1762 }
1763 else
1764 {
1765 returnCode = ADDR_ERROR;
1766 }
1767
1768 ADDR_RESET_DEBUG_PRINTERS();
1769 return returnCode;
1770 }
1771
1772 /**
1773 ****************************************************************************************************
1774 * Addr2ComputeSlicePipeBankXor
1775 *
1776 * @brief
1777 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
1778 ****************************************************************************************************
1779 */
Addr2ComputeSlicePipeBankXor(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT * pIn,ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT * pOut)1780 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
1781 ADDR_HANDLE hLib, ///< handle of addrlib
1782 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
1783 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
1784 {
1785 ADDR_E_RETURNCODE returnCode;
1786
1787 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1788
1789 if (pLib != NULL)
1790 {
1791 returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
1792 }
1793 else
1794 {
1795 returnCode = ADDR_ERROR;
1796 }
1797
1798 ADDR_RESET_DEBUG_PRINTERS();
1799 return returnCode;
1800 }
1801
1802 /**
1803 ****************************************************************************************************
1804 * Addr2ComputeSubResourceOffsetForSwizzlePattern
1805 *
1806 * @brief
1807 * Calculate sub resource offset for swizzle pattern.
1808 ****************************************************************************************************
1809 */
Addr2ComputeSubResourceOffsetForSwizzlePattern(ADDR_HANDLE hLib,const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT * pIn,ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT * pOut)1810 ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
1811 ADDR_HANDLE hLib, ///< handle of addrlib
1812 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, ///< [in] input
1813 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) ///< [out] output
1814 {
1815 ADDR_E_RETURNCODE returnCode;
1816
1817 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1818
1819 if (pLib != NULL)
1820 {
1821 returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
1822 }
1823 else
1824 {
1825 returnCode = ADDR_ERROR;
1826 }
1827
1828 ADDR_RESET_DEBUG_PRINTERS();
1829 return returnCode;
1830 }
1831
1832 /**
1833 ****************************************************************************************************
1834 * Addr2ComputeNonBlockCompressedView
1835 *
1836 * @brief
1837 * Compute non-block-compressed view for a given mipmap level/slice.
1838 ****************************************************************************************************
1839 */
Addr2ComputeNonBlockCompressedView(ADDR_HANDLE hLib,const ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT * pIn,ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT * pOut)1840 ADDR_E_RETURNCODE ADDR_API Addr2ComputeNonBlockCompressedView(
1841 ADDR_HANDLE hLib, ///< handle of addrlib
1842 const ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, ///< [in] input
1843 ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut) ///< [out] output
1844 {
1845 ADDR_E_RETURNCODE returnCode;
1846
1847 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1848
1849 if (pLib != NULL)
1850 {
1851 returnCode = pLib->ComputeNonBlockCompressedView(pIn, pOut);
1852 }
1853 else
1854 {
1855 returnCode = ADDR_ERROR;
1856 }
1857
1858 ADDR_RESET_DEBUG_PRINTERS();
1859 return returnCode;
1860 }
1861
1862 /**
1863 ****************************************************************************************************
1864 * Addr2GetPreferredSurfaceSetting
1865 *
1866 * @brief
1867 * Suggest a preferred setting for client driver to program HW register
1868 ****************************************************************************************************
1869 */
Addr2GetPreferredSurfaceSetting(ADDR_HANDLE hLib,const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT * pIn,ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT * pOut)1870 ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
1871 ADDR_HANDLE hLib, ///< handle of addrlib
1872 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn, ///< [in] input
1873 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) ///< [out] output
1874 {
1875 ADDR_E_RETURNCODE returnCode;
1876
1877 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1878
1879 if (pLib != NULL)
1880 {
1881 returnCode = pLib->Addr2GetPreferredSurfaceSetting(pIn, pOut);
1882 }
1883 else
1884 {
1885 returnCode = ADDR_ERROR;
1886 }
1887
1888 ADDR_RESET_DEBUG_PRINTERS();
1889 return returnCode;
1890 }
1891
1892 /**
1893 ****************************************************************************************************
1894 * Addr2IsValidDisplaySwizzleMode
1895 *
1896 * @brief
1897 * Return whether the swizzle mode is supported by display engine
1898 ****************************************************************************************************
1899 */
Addr2IsValidDisplaySwizzleMode(ADDR_HANDLE hLib,AddrSwizzleMode swizzleMode,UINT_32 bpp,BOOL_32 * pResult)1900 ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
1901 ADDR_HANDLE hLib,
1902 AddrSwizzleMode swizzleMode,
1903 UINT_32 bpp,
1904 BOOL_32 *pResult)
1905 {
1906 ADDR_E_RETURNCODE returnCode;
1907
1908 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1909
1910 if (pLib != NULL)
1911 {
1912 ADDR2_COMPUTE_SURFACE_INFO_INPUT in = {};
1913 in.resourceType = ADDR_RSRC_TEX_2D;
1914 in.swizzleMode = swizzleMode;
1915 in.bpp = bpp;
1916
1917 BOOL_32 result = pLib->IsValidDisplaySwizzleMode(&in);
1918 if (pResult != NULL)
1919 {
1920 *pResult = result;
1921 }
1922
1923 returnCode = ADDR_OK;
1924 }
1925 else
1926 {
1927 returnCode = ADDR_ERROR;
1928 }
1929
1930 ADDR_RESET_DEBUG_PRINTERS();
1931 return returnCode;
1932 }
1933
1934 /**
1935 ****************************************************************************************************
1936 * Addr2GetPossibleSwizzleModes
1937 *
1938 * @brief
1939 * Returns a list of swizzle modes that are valid from the hardware's perspective for the
1940 * client to choose from
1941 ****************************************************************************************************
1942 */
Addr2GetPossibleSwizzleModes(ADDR_HANDLE hLib,const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT * pIn,ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT * pOut)1943 ADDR_E_RETURNCODE ADDR_API Addr2GetPossibleSwizzleModes(
1944 ADDR_HANDLE hLib, ///< handle of addrlib
1945 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn, ///< [in] input
1946 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) ///< [out] output
1947 {
1948 ADDR_E_RETURNCODE returnCode;
1949
1950 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1951
1952 if (pLib != NULL)
1953 {
1954 returnCode = pLib->GetPossibleSwizzleModes(pIn, pOut);
1955 }
1956 else
1957 {
1958 returnCode = ADDR_ERROR;
1959 }
1960
1961 ADDR_RESET_DEBUG_PRINTERS();
1962 return returnCode;
1963 }
1964 /**
1965 ****************************************************************************************************
1966 * Addr2GetAllowedBlockSet
1967 *
1968 * @brief
1969 * Returns the set of allowed block sizes given the allowed swizzle modes and resource type
1970 ****************************************************************************************************
1971 */
Addr2GetAllowedBlockSet(ADDR_HANDLE hLib,ADDR2_SWMODE_SET allowedSwModeSet,AddrResourceType rsrcType,ADDR2_BLOCK_SET * pAllowedBlockSet)1972 ADDR_E_RETURNCODE ADDR_API Addr2GetAllowedBlockSet(
1973 ADDR_HANDLE hLib, ///< handle of addrlib
1974 ADDR2_SWMODE_SET allowedSwModeSet, ///< [in] allowed swizzle modes
1975 AddrResourceType rsrcType, ///< [in] resource type
1976 ADDR2_BLOCK_SET* pAllowedBlockSet) ///< [out] allowed block sizes
1977 {
1978 ADDR_E_RETURNCODE returnCode;
1979
1980 V2::Lib* pLib = V2::Lib::GetLib(hLib);
1981
1982 if (pLib != NULL)
1983 {
1984 returnCode = pLib->GetAllowedBlockSet(allowedSwModeSet, rsrcType, pAllowedBlockSet);
1985 }
1986 else
1987 {
1988 returnCode = ADDR_ERROR;
1989 }
1990
1991 ADDR_RESET_DEBUG_PRINTERS();
1992 return returnCode;
1993 }
1994
1995 /**
1996 ****************************************************************************************************
1997 * Addr2GetAllowedSwSet
1998 *
1999 * @brief
2000 * Returns the set of allowed swizzle types given the allowed swizzle modes
2001 ****************************************************************************************************
2002 */
Addr2GetAllowedSwSet(ADDR_HANDLE hLib,ADDR2_SWMODE_SET allowedSwModeSet,ADDR2_SWTYPE_SET * pAllowedSwSet)2003 ADDR_E_RETURNCODE ADDR_API Addr2GetAllowedSwSet(
2004 ADDR_HANDLE hLib, ///< handle of addrlib
2005 ADDR2_SWMODE_SET allowedSwModeSet, ///< [in] allowed swizzle modes
2006 ADDR2_SWTYPE_SET* pAllowedSwSet) ///< [out] allowed swizzle types
2007 {
2008 ADDR_E_RETURNCODE returnCode;
2009
2010 V2::Lib* pLib = V2::Lib::GetLib(hLib);
2011
2012 if (pLib != NULL)
2013 {
2014 returnCode = pLib->GetAllowedSwSet(allowedSwModeSet, pAllowedSwSet);
2015 }
2016 else
2017 {
2018 returnCode = ADDR_ERROR;
2019 }
2020
2021 ADDR_RESET_DEBUG_PRINTERS();
2022 return returnCode;
2023 }
2024
2025 /**
2026 ****************************************************************************************************
2027 * Addr2IsBlockTypeAvailable
2028 *
2029 * @brief
2030 * Determine whether a block type is allowed in a given blockSet
2031 ****************************************************************************************************
2032 */
Addr2IsBlockTypeAvailable(ADDR2_BLOCK_SET blockSet,AddrBlockType blockType)2033 BOOL_32 Addr2IsBlockTypeAvailable(
2034 ADDR2_BLOCK_SET blockSet,
2035 AddrBlockType blockType)
2036 {
2037 BOOL_32 avail;
2038
2039 if (blockType == AddrBlockLinear)
2040 {
2041 avail = blockSet.linear ? TRUE : FALSE;
2042 }
2043 else
2044 {
2045 avail = blockSet.value & (1 << (static_cast<UINT_32>(blockType) - 1)) ? TRUE : FALSE;
2046 }
2047
2048 ADDR_RESET_DEBUG_PRINTERS();
2049 return avail;
2050 }
2051
2052 /**
2053 ****************************************************************************************************
2054 * Addr2BlockTypeWithinMemoryBudget
2055 *
2056 * @brief
2057 * Determine whether a new block type is acceptable based on memory waste ratio. Will favor
2058 * larger block types.
2059 ****************************************************************************************************
2060 */
Addr2BlockTypeWithinMemoryBudget(UINT_64 minSize,UINT_64 newBlockTypeSize,UINT_32 ratioLow,UINT_32 ratioHi,DOUBLE memoryBudget,BOOL_32 newBlockTypeBigger)2061 BOOL_32 Addr2BlockTypeWithinMemoryBudget(
2062 UINT_64 minSize,
2063 UINT_64 newBlockTypeSize,
2064 UINT_32 ratioLow,
2065 UINT_32 ratioHi,
2066 DOUBLE memoryBudget,
2067 BOOL_32 newBlockTypeBigger)
2068 {
2069 BOOL_32 accept = FALSE;
2070
2071 if (memoryBudget >= 1.0)
2072 {
2073 if (newBlockTypeBigger)
2074 {
2075 if ((static_cast<DOUBLE>(newBlockTypeSize) / minSize) <= memoryBudget)
2076 {
2077 accept = TRUE;
2078 }
2079 }
2080 else
2081 {
2082 if ((static_cast<DOUBLE>(minSize) / newBlockTypeSize) > memoryBudget)
2083 {
2084 accept = TRUE;
2085 }
2086 }
2087 }
2088 else
2089 {
2090 if (newBlockTypeBigger)
2091 {
2092 if ((newBlockTypeSize * ratioHi) <= (minSize * ratioLow))
2093 {
2094 accept = TRUE;
2095 }
2096 }
2097 else
2098 {
2099 if ((newBlockTypeSize * ratioLow) < (minSize * ratioHi))
2100 {
2101 accept = TRUE;
2102 }
2103 }
2104 }
2105
2106 ADDR_RESET_DEBUG_PRINTERS();
2107 return accept;
2108 }
2109
2110 ////////////////////////////////////////////////////////////////////////////////////////////////////
2111 // Surface functions for Addr3
2112 ////////////////////////////////////////////////////////////////////////////////////////////////////
2113
2114 /**
2115 ****************************************************************************************************
2116 * Addr3ComputeSurfaceInfo
2117 *
2118 * @brief
2119 * Calculate surface width/height/depth/alignments and suitable tiling mode
2120 *
2121 * @return
2122 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
2123 ****************************************************************************************************
2124 */
Addr3ComputeSurfaceInfo(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SURFACE_INFO_INPUT * pIn,ADDR3_COMPUTE_SURFACE_INFO_OUTPUT * pOut)2125 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSurfaceInfo(
2126 ADDR_HANDLE hLib, ///< address lib handle
2127 const ADDR3_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information
2128 ADDR3_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments
2129 {
2130 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2131
2132 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2133
2134 if (pLib != NULL)
2135 {
2136 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
2137 }
2138
2139 ADDR_RESET_DEBUG_PRINTERS();
2140 return returnCode;
2141 }
2142
2143 /**
2144 ****************************************************************************************************
2145 * Addr3GetPossibleSwizzleModes
2146 *
2147 * @brief
2148 * Get valid swizzle mode options given image input for further optimal selection
2149 *
2150 * @return
2151 * ADDR_OK if successful, otherwise an error code of ADDR_PARAMSIZEMISMATCH
2152 ****************************************************************************************************
2153 */
Addr3GetPossibleSwizzleModes(ADDR_HANDLE hLib,const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT * pIn,ADDR3_GET_POSSIBLE_SWIZZLE_MODE_OUTPUT * pOut)2154 ADDR_E_RETURNCODE ADDR_API Addr3GetPossibleSwizzleModes(
2155 ADDR_HANDLE hLib, ///< address lib handle
2156 const ADDR3_GET_POSSIBLE_SWIZZLE_MODE_INPUT* pIn, ///< [in] surface information
2157 ADDR3_GET_POSSIBLE_SWIZZLE_MODE_OUTPUT* pOut) ///< [out] allowable swizzle mdoes
2158 {
2159 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2160
2161 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2162
2163 if (pLib != NULL)
2164 {
2165 returnCode = pLib->GetPossibleSwizzleModes(pIn, pOut);
2166 }
2167
2168 ADDR_RESET_DEBUG_PRINTERS();
2169 return returnCode;
2170 }
2171
2172 /**
2173 ****************************************************************************************************
2174 * Addr3ComputeSurfaceAddrFromCoord
2175 *
2176 * @brief
2177 * Compute surface address according to coordinates
2178 *
2179 * @return
2180 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
2181 ****************************************************************************************************
2182 */
Addr3ComputeSurfaceAddrFromCoord(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT * pIn,ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT * pOut)2183 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSurfaceAddrFromCoord(
2184 ADDR_HANDLE hLib, ///< address lib handle
2185 const ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates
2186 ADDR3_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address
2187 {
2188 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2189
2190 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2191
2192 if (pLib != NULL)
2193 {
2194 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
2195 }
2196 else
2197 {
2198 returnCode = ADDR_ERROR;
2199 }
2200
2201 ADDR_RESET_DEBUG_PRINTERS();
2202 return returnCode;
2203 }
2204
2205 /**
2206 ****************************************************************************************************
2207 * Addr3CopyMemToSurface
2208 *
2209 * @brief
2210 * Copy an image region from memory to an uncompressed CPU-mapped surface
2211 *
2212 * @return
2213 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
2214 ****************************************************************************************************
2215 */
Addr3CopyMemToSurface(ADDR_HANDLE hLib,const ADDR3_COPY_MEMSURFACE_INPUT * pIn,const ADDR3_COPY_MEMSURFACE_REGION * pRegions,UINT_32 regionCount)2216 ADDR_E_RETURNCODE ADDR_API Addr3CopyMemToSurface(
2217 ADDR_HANDLE hLib, ///< address lib handle
2218 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, ///< [in] description of image and mapping
2219 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, ///< [in] list of copy regions
2220 UINT_32 regionCount) ///< [in] count of copy regions in list
2221 {
2222 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2223
2224 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2225
2226 if (pLib != NULL)
2227 {
2228 returnCode = pLib->CopyMemToSurface(pIn, pRegions, regionCount);
2229 }
2230 else
2231 {
2232 returnCode = ADDR_ERROR;
2233 }
2234
2235 return returnCode;
2236 }
2237
2238 /**
2239 ****************************************************************************************************
2240 * Addr3CopySurfaceToMem
2241 *
2242 * @brief
2243 * Copy an image region from an uncompressed CPU-mapped surface to memory
2244 *
2245 * @return
2246 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
2247 ****************************************************************************************************
2248 */
Addr3CopySurfaceToMem(ADDR_HANDLE hLib,const ADDR3_COPY_MEMSURFACE_INPUT * pIn,const ADDR3_COPY_MEMSURFACE_REGION * pRegions,UINT_32 regionCount)2249 ADDR_E_RETURNCODE ADDR_API Addr3CopySurfaceToMem(
2250 ADDR_HANDLE hLib, ///< address lib handle
2251 const ADDR3_COPY_MEMSURFACE_INPUT* pIn, ///< [in] description of image and mapping
2252 const ADDR3_COPY_MEMSURFACE_REGION* pRegions, ///< [in] list of copy regions
2253 UINT_32 regionCount) ///< [in] count of copy regions in list
2254 {
2255 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2256
2257 ADDR_E_RETURNCODE returnCode = ADDR_OK;
2258
2259 if (pLib != NULL)
2260 {
2261 returnCode = pLib->CopySurfaceToMem(pIn, pRegions, regionCount);
2262 }
2263 else
2264 {
2265 returnCode = ADDR_ERROR;
2266 }
2267
2268 return returnCode;
2269 }
2270
2271 /**
2272 ****************************************************************************************************
2273 * Addr3ComputePipeBankXor
2274 *
2275 * @brief
2276 * Calculate a valid bank pipe xor value for client to use.
2277 ****************************************************************************************************
2278 */
Addr3ComputePipeBankXor(ADDR_HANDLE hLib,const ADDR3_COMPUTE_PIPEBANKXOR_INPUT * pIn,ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT * pOut)2279 ADDR_E_RETURNCODE ADDR_API Addr3ComputePipeBankXor(
2280 ADDR_HANDLE hLib, ///< handle of addrlib
2281 const ADDR3_COMPUTE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
2282 ADDR3_COMPUTE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
2283 {
2284 ADDR_E_RETURNCODE returnCode;
2285
2286 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2287
2288 if (pLib != NULL)
2289 {
2290 returnCode = pLib->ComputePipeBankXor(pIn, pOut);
2291 }
2292 else
2293 {
2294 returnCode = ADDR_ERROR;
2295 }
2296
2297 ADDR_RESET_DEBUG_PRINTERS();
2298 return returnCode;
2299 }
2300
2301 /**
2302 ****************************************************************************************************
2303 * Addr3ComputeNonBlockCompressedView
2304 *
2305 * @brief
2306 * Compute non-block-compressed view for a given mipmap level/slice.
2307 ****************************************************************************************************
2308 */
Addr3ComputeNonBlockCompressedView(ADDR_HANDLE hLib,const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT * pIn,ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT * pOut)2309 ADDR_E_RETURNCODE ADDR_API Addr3ComputeNonBlockCompressedView(
2310 ADDR_HANDLE hLib, ///< handle of addrlib
2311 const ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn, ///< [in] input
2312 ADDR3_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT* pOut) ///< [out] output
2313 {
2314 ADDR_E_RETURNCODE returnCode;
2315
2316 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2317
2318 if (pLib != NULL)
2319 {
2320 returnCode = pLib->ComputeNonBlockCompressedView(pIn, pOut);
2321 }
2322 else
2323 {
2324 returnCode = ADDR_ERROR;
2325 }
2326
2327 ADDR_RESET_DEBUG_PRINTERS();
2328 return returnCode;
2329 }
2330
2331 /**
2332 ****************************************************************************************************
2333 * Addr3ComputeSubResourceOffsetForSwizzlePattern
2334 *
2335 * @brief
2336 * Calculate sub resource offset for swizzle pattern.
2337 ****************************************************************************************************
2338 */
Addr3ComputeSubResourceOffsetForSwizzlePattern(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT * pIn,ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT * pOut)2339 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSubResourceOffsetForSwizzlePattern(
2340 ADDR_HANDLE hLib, ///< handle of addrlib
2341 const ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn, ///< [in] input
2342 ADDR3_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut) ///< [out] output
2343 {
2344 ADDR_E_RETURNCODE returnCode = ADDR_ERROR;
2345 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2346
2347 if (pLib != NULL)
2348 {
2349 returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
2350 }
2351 ADDR_RESET_DEBUG_PRINTERS();
2352
2353 return returnCode;
2354 }
2355
2356 /**
2357 ****************************************************************************************************
2358 * Addr3ComputeSlicePipeBankXor
2359 *
2360 * @brief
2361 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
2362 ****************************************************************************************************
2363 */
Addr3ComputeSlicePipeBankXor(ADDR_HANDLE hLib,const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT * pIn,ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT * pOut)2364 ADDR_E_RETURNCODE ADDR_API Addr3ComputeSlicePipeBankXor(
2365 ADDR_HANDLE hLib, ///< handle of addrlib
2366 const ADDR3_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn, ///< [in] input
2367 ADDR3_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut) ///< [out] output
2368 {
2369 ADDR_E_RETURNCODE returnCode;
2370
2371 V3::Lib* pLib = V3::Lib::GetLib(hLib);
2372
2373 if (pLib != NULL)
2374 {
2375 returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
2376 }
2377 else
2378 {
2379 returnCode = ADDR_ERROR;
2380 }
2381
2382 ADDR_RESET_DEBUG_PRINTERS();
2383 return returnCode;
2384 }
2385