2 * Copyright © 2007-2019 Advanced Micro Devices, Inc.
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
14 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
15 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16 * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
17 * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
28 ****************************************************************************************************
29 * @file addrinterface.cpp
30 * @brief Contains the addrlib interface functions
31 ****************************************************************************************************
33 #include "addrinterface.h"
37 #include "addrcommon.h"
39 #include "util/macros.h"
43 ////////////////////////////////////////////////////////////////////////////////////////////////////
44 // Create/Destroy/Config functions
45 ////////////////////////////////////////////////////////////////////////////////////////////////////
48 ****************************************************************************************************
52 * Create address lib object
55 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
56 ****************************************************************************************************
58 ADDR_E_RETURNCODE ADDR_API
AddrCreate(
59 const ADDR_CREATE_INPUT
* pAddrCreateIn
, ///< [in] infomation for creating address lib object
60 ADDR_CREATE_OUTPUT
* pAddrCreateOut
) ///< [out] address lib handle
62 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
64 returnCode
= Lib::Create(pAddrCreateIn
, pAddrCreateOut
);
71 ****************************************************************************************************
75 * Destroy address lib object
78 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
79 ****************************************************************************************************
81 ADDR_E_RETURNCODE ADDR_API
AddrDestroy(
82 ADDR_HANDLE hLib
) ///< address lib handle
84 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
88 Lib
* pLib
= Lib::GetLib(hLib
);
93 returnCode
= ADDR_ERROR
;
99 ////////////////////////////////////////////////////////////////////////////////////////////////////
101 ////////////////////////////////////////////////////////////////////////////////////////////////////
104 ****************************************************************************************************
105 * AddrComputeSurfaceInfo
108 * Calculate surface width/height/depth/alignments and suitable tiling mode
111 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
112 ****************************************************************************************************
114 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceInfo(
115 ADDR_HANDLE hLib
, ///< address lib handle
116 const ADDR_COMPUTE_SURFACE_INFO_INPUT
* pIn
, ///< [in] surface information
117 ADDR_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) ///< [out] surface parameters and alignments
119 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
121 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
125 returnCode
= pLib
->ComputeSurfaceInfo(pIn
, pOut
);
129 returnCode
= ADDR_ERROR
;
136 ****************************************************************************************************
137 * AddrComputeSurfaceAddrFromCoord
140 * Compute surface address according to coordinates
143 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
144 ****************************************************************************************************
146 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceAddrFromCoord(
147 ADDR_HANDLE hLib
, ///< address lib handle
148 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] surface info and coordinates
149 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] surface address
151 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
153 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
157 returnCode
= pLib
->ComputeSurfaceAddrFromCoord(pIn
, pOut
);
161 returnCode
= ADDR_ERROR
;
168 ****************************************************************************************************
169 * AddrComputeSurfaceCoordFromAddr
172 * Compute coordinates according to surface address
175 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
176 ****************************************************************************************************
178 ADDR_E_RETURNCODE ADDR_API
AddrComputeSurfaceCoordFromAddr(
179 ADDR_HANDLE hLib
, ///< address lib handle
180 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
, ///< [in] surface info and address
181 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] coordinates
183 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
185 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
189 returnCode
= pLib
->ComputeSurfaceCoordFromAddr(pIn
, pOut
);
193 returnCode
= ADDR_ERROR
;
199 ////////////////////////////////////////////////////////////////////////////////////////////////////
201 ////////////////////////////////////////////////////////////////////////////////////////////////////
204 ****************************************************************************************************
205 * AddrComputeHtileInfo
208 * Compute Htile pitch, height, base alignment and size in bytes
211 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
212 ****************************************************************************************************
214 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileInfo(
215 ADDR_HANDLE hLib
, ///< address lib handle
216 const ADDR_COMPUTE_HTILE_INFO_INPUT
* pIn
, ///< [in] Htile information
217 ADDR_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) ///< [out] Htile pitch, height and size in bytes
219 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
221 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
225 returnCode
= pLib
->ComputeHtileInfo(pIn
, pOut
);
229 returnCode
= ADDR_ERROR
;
236 ****************************************************************************************************
237 * AddrComputeHtileAddrFromCoord
240 * Compute Htile address according to coordinates (of depth buffer)
243 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
244 ****************************************************************************************************
246 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileAddrFromCoord(
247 ADDR_HANDLE hLib
, ///< address lib handle
248 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Htile info and coordinates
249 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Htile address
251 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
253 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
257 returnCode
= pLib
->ComputeHtileAddrFromCoord(pIn
, pOut
);
261 returnCode
= ADDR_ERROR
;
268 ****************************************************************************************************
269 * AddrComputeHtileCoordFromAddr
272 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
276 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
277 ****************************************************************************************************
279 ADDR_E_RETURNCODE ADDR_API
AddrComputeHtileCoordFromAddr(
280 ADDR_HANDLE hLib
, ///< address lib handle
281 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
, ///< [in] Htile info and address
282 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Htile coordinates
284 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
286 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
290 returnCode
= pLib
->ComputeHtileCoordFromAddr(pIn
, pOut
);
294 returnCode
= ADDR_ERROR
;
300 ////////////////////////////////////////////////////////////////////////////////////////////////////
302 ////////////////////////////////////////////////////////////////////////////////////////////////////
305 ****************************************************************************************************
306 * AddrComputeCmaskInfo
309 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
313 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
314 ****************************************************************************************************
316 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskInfo(
317 ADDR_HANDLE hLib
, ///< address lib handle
318 const ADDR_COMPUTE_CMASK_INFO_INPUT
* pIn
, ///< [in] Cmask pitch and height
319 ADDR_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) ///< [out] Cmask pitch, height and size in bytes
321 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
323 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
327 returnCode
= pLib
->ComputeCmaskInfo(pIn
, pOut
);
331 returnCode
= ADDR_ERROR
;
338 ****************************************************************************************************
339 * AddrComputeCmaskAddrFromCoord
342 * Compute Cmask address according to coordinates (of MSAA color buffer)
345 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
346 ****************************************************************************************************
348 ADDR_E_RETURNCODE ADDR_API
AddrComputeCmaskAddrFromCoord(
349 ADDR_HANDLE hLib
, ///< address lib handle
350 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Cmask info and coordinates
351 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Cmask address
353 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
355 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
359 returnCode
= pLib
->ComputeCmaskAddrFromCoord(pIn
, pOut
);
363 returnCode
= ADDR_ERROR
;
370 ****************************************************************************************************
371 * AddrComputeCmaskCoordFromAddr
374 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
378 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
379 ****************************************************************************************************
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
386 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
388 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
392 returnCode
= pLib
->ComputeCmaskCoordFromAddr(pIn
, pOut
);
396 returnCode
= ADDR_ERROR
;
402 ////////////////////////////////////////////////////////////////////////////////////////////////////
404 ////////////////////////////////////////////////////////////////////////////////////////////////////
407 ****************************************************************************************************
408 * AddrComputeFmaskInfo
411 * Compute Fmask pitch/height/depth/alignments and size in bytes
414 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
415 ****************************************************************************************************
417 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskInfo(
418 ADDR_HANDLE hLib
, ///< address lib handle
419 const ADDR_COMPUTE_FMASK_INFO_INPUT
* pIn
, ///< [in] Fmask information
420 ADDR_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) ///< [out] Fmask pitch and height
422 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
424 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
428 returnCode
= pLib
->ComputeFmaskInfo(pIn
, pOut
);
432 returnCode
= ADDR_ERROR
;
439 ****************************************************************************************************
440 * AddrComputeFmaskAddrFromCoord
443 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
446 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
447 ****************************************************************************************************
449 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskAddrFromCoord(
450 ADDR_HANDLE hLib
, ///< address lib handle
451 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Fmask info and coordinates
452 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Fmask address
454 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
456 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
460 returnCode
= pLib
->ComputeFmaskAddrFromCoord(pIn
, pOut
);
464 returnCode
= ADDR_ERROR
;
471 ****************************************************************************************************
472 * AddrComputeFmaskCoordFromAddr
475 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
478 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
479 ****************************************************************************************************
481 ADDR_E_RETURNCODE ADDR_API
AddrComputeFmaskCoordFromAddr(
482 ADDR_HANDLE hLib
, ///< address lib handle
483 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Fmask info and address
484 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Fmask coordinates
486 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
488 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
492 returnCode
= pLib
->ComputeFmaskCoordFromAddr(pIn
, pOut
);
496 returnCode
= ADDR_ERROR
;
502 ////////////////////////////////////////////////////////////////////////////////////////////////////
504 ////////////////////////////////////////////////////////////////////////////////////////////////////
507 ****************************************************************************************************
511 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
513 ****************************************************************************************************
515 ADDR_E_RETURNCODE ADDR_API
AddrComputeDccInfo(
516 ADDR_HANDLE hLib
, ///< handle of addrlib
517 const ADDR_COMPUTE_DCCINFO_INPUT
* pIn
, ///< [in] input
518 ADDR_COMPUTE_DCCINFO_OUTPUT
* pOut
) ///< [out] output
520 ADDR_E_RETURNCODE returnCode
;
522 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
526 returnCode
= pLib
->ComputeDccInfo(pIn
, pOut
);
530 returnCode
= ADDR_ERROR
;
536 ///////////////////////////////////////////////////////////////////////////////
537 // Below functions are element related or helper functions
538 ///////////////////////////////////////////////////////////////////////////////
541 ****************************************************************************************************
545 * Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION
546 * defined in addrinterface.h to see if there is a mismatch.
547 ****************************************************************************************************
549 UINT_32 ADDR_API
AddrGetVersion(ADDR_HANDLE hLib
)
553 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
555 ADDR_ASSERT(pLib
!= NULL
);
559 version
= pLib
->GetVersion();
566 ****************************************************************************************************
570 * Return TRUE if tileIndex is enabled in this address library
571 ****************************************************************************************************
573 BOOL_32 ADDR_API
AddrUseTileIndex(ADDR_HANDLE hLib
)
575 BOOL_32 useTileIndex
= FALSE
;
577 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
579 ADDR_ASSERT(pLib
!= NULL
);
583 useTileIndex
= pLib
->UseTileIndex(0);
590 ****************************************************************************************************
591 * AddrUseCombinedSwizzle
594 * Return TRUE if combined swizzle is enabled in this address library
595 ****************************************************************************************************
597 BOOL_32 ADDR_API
AddrUseCombinedSwizzle(ADDR_HANDLE hLib
)
599 BOOL_32 useCombinedSwizzle
= FALSE
;
601 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
603 ADDR_ASSERT(pLib
!= NULL
);
607 useCombinedSwizzle
= pLib
->UseCombinedSwizzle();
610 return useCombinedSwizzle
;
614 ****************************************************************************************************
615 * AddrExtractBankPipeSwizzle
618 * Extract Bank and Pipe swizzle from base256b
620 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
621 ****************************************************************************************************
623 ADDR_E_RETURNCODE ADDR_API
AddrExtractBankPipeSwizzle(
624 ADDR_HANDLE hLib
, ///< addrlib handle
625 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
* pIn
, ///< [in] input structure
626 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
* pOut
) ///< [out] output structure
628 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
630 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
634 returnCode
= pLib
->ExtractBankPipeSwizzle(pIn
, pOut
);
638 returnCode
= ADDR_ERROR
;
645 ****************************************************************************************************
646 * AddrCombineBankPipeSwizzle
649 * Combine Bank and Pipe swizzle
652 ****************************************************************************************************
654 ADDR_E_RETURNCODE ADDR_API
AddrCombineBankPipeSwizzle(
656 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
* pIn
,
657 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
* pOut
)
659 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
661 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
665 returnCode
= pLib
->CombineBankPipeSwizzle(pIn
, pOut
);
669 returnCode
= ADDR_ERROR
;
676 ****************************************************************************************************
677 * AddrComputeSliceSwizzle
680 * Compute a swizzle for slice from a base swizzle
682 * ADDR_OK if no error
683 ****************************************************************************************************
685 ADDR_E_RETURNCODE ADDR_API
AddrComputeSliceSwizzle(
687 const ADDR_COMPUTE_SLICESWIZZLE_INPUT
* pIn
,
688 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
* pOut
)
690 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
692 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
696 returnCode
= pLib
->ComputeSliceTileSwizzle(pIn
, pOut
);
700 returnCode
= ADDR_ERROR
;
707 ****************************************************************************************************
708 * AddrComputeBaseSwizzle
711 * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
713 * ADDR_OK if no error
714 ****************************************************************************************************
716 ADDR_E_RETURNCODE ADDR_API
AddrComputeBaseSwizzle(
718 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT
* pIn
,
719 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
* pOut
)
721 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
723 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
727 returnCode
= pLib
->ComputeBaseSwizzle(pIn
, pOut
);
731 returnCode
= ADDR_ERROR
;
738 ****************************************************************************************************
739 * ElemFlt32ToDepthPixel
742 * Convert a FLT_32 value to a depth/stencil pixel value
745 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
747 ****************************************************************************************************
749 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToDepthPixel(
750 ADDR_HANDLE hLib
, ///< addrlib handle
751 const ELEM_FLT32TODEPTHPIXEL_INPUT
* pIn
, ///< [in] per-component value
752 ELEM_FLT32TODEPTHPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
754 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
756 Lib
* pLib
= Lib::GetLib(hLib
);
760 pLib
->Flt32ToDepthPixel(pIn
, pOut
);
764 returnCode
= ADDR_ERROR
;
771 ****************************************************************************************************
772 * ElemFlt32ToColorPixel
775 * Convert a FLT_32 value to a red/green/blue/alpha pixel value
778 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
780 ****************************************************************************************************
782 ADDR_E_RETURNCODE ADDR_API
ElemFlt32ToColorPixel(
783 ADDR_HANDLE hLib
, ///< addrlib handle
784 const ELEM_FLT32TOCOLORPIXEL_INPUT
* pIn
, ///< [in] format, surface number and swap value
785 ELEM_FLT32TOCOLORPIXEL_OUTPUT
* pOut
) ///< [out] final pixel value
787 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
789 Lib
* pLib
= Lib::GetLib(hLib
);
793 pLib
->Flt32ToColorPixel(pIn
, pOut
);
797 returnCode
= ADDR_ERROR
;
804 ****************************************************************************************************
808 * Helper function to check one format can be EXPORT_NUM,
809 * which is a register CB_COLOR_INFO.SURFACE_FORMAT.
810 * FP16 can be reported as EXPORT_NORM for rv770 in r600
813 ****************************************************************************************************
815 BOOL_32 ADDR_API
ElemGetExportNorm(
816 ADDR_HANDLE hLib
, ///< addrlib handle
817 const ELEM_GETEXPORTNORM_INPUT
* pIn
) ///< [in] input structure
819 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
820 BOOL_32 enabled
= FALSE
;
822 ASSERTED ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
826 enabled
= pLib
->GetExportNorm(pIn
);
830 returnCode
= ADDR_ERROR
;
833 ADDR_ASSERT(returnCode
== ADDR_OK
);
839 ****************************************************************************************************
843 * Get bits-per-element for specified format
846 * Bits-per-element of specified format
848 ****************************************************************************************************
850 UINT_32 ADDR_API
ElemSize(
856 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
860 bpe
= pLib
->GetBpe(format
);
867 ****************************************************************************************************
868 * AddrConvertTileInfoToHW
871 * Convert tile info from real value to hardware register value
874 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
875 ****************************************************************************************************
877 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileInfoToHW(
878 ADDR_HANDLE hLib
, ///< address lib handle
879 const ADDR_CONVERT_TILEINFOTOHW_INPUT
* pIn
, ///< [in] tile info with real value
880 ADDR_CONVERT_TILEINFOTOHW_OUTPUT
* pOut
) ///< [out] tile info with HW register value
882 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
884 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
888 returnCode
= pLib
->ConvertTileInfoToHW(pIn
, pOut
);
892 returnCode
= ADDR_ERROR
;
899 ****************************************************************************************************
900 * AddrConvertTileIndex
903 * Convert tile index to tile mode/type/info
906 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
907 ****************************************************************************************************
909 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex(
910 ADDR_HANDLE hLib
, ///< address lib handle
911 const ADDR_CONVERT_TILEINDEX_INPUT
* pIn
, ///< [in] input - tile index
912 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
914 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
916 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
920 returnCode
= pLib
->ConvertTileIndex(pIn
, pOut
);
924 returnCode
= ADDR_ERROR
;
931 ****************************************************************************************************
932 * AddrGetMacroModeIndex
935 * Get macro mode index based on input parameters
938 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
939 ****************************************************************************************************
941 ADDR_E_RETURNCODE ADDR_API
AddrGetMacroModeIndex(
942 ADDR_HANDLE hLib
, ///< address lib handle
943 const ADDR_GET_MACROMODEINDEX_INPUT
* pIn
, ///< [in] input
944 ADDR_GET_MACROMODEINDEX_OUTPUT
* pOut
) ///< [out] macro mode index
946 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
948 ADDR_E_RETURNCODE returnCode
;
952 returnCode
= pLib
->GetMacroModeIndex(pIn
, pOut
);
956 returnCode
= ADDR_ERROR
;
963 ****************************************************************************************************
964 * AddrConvertTileIndex1
967 * Convert tile index to tile mode/type/info
970 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
971 ****************************************************************************************************
973 ADDR_E_RETURNCODE ADDR_API
AddrConvertTileIndex1(
974 ADDR_HANDLE hLib
, ///< address lib handle
975 const ADDR_CONVERT_TILEINDEX1_INPUT
* pIn
, ///< [in] input - tile index
976 ADDR_CONVERT_TILEINDEX_OUTPUT
* pOut
) ///< [out] tile mode/type/info
978 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
980 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
984 returnCode
= pLib
->ConvertTileIndex1(pIn
, pOut
);
988 returnCode
= ADDR_ERROR
;
995 ****************************************************************************************************
999 * Get tile index from tile mode/type/info
1002 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1005 * Only meaningful for SI (and above)
1006 ****************************************************************************************************
1008 ADDR_E_RETURNCODE ADDR_API
AddrGetTileIndex(
1010 const ADDR_GET_TILEINDEX_INPUT
* pIn
,
1011 ADDR_GET_TILEINDEX_OUTPUT
* pOut
)
1013 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
1015 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1019 returnCode
= pLib
->GetTileIndex(pIn
, pOut
);
1023 returnCode
= ADDR_ERROR
;
1030 ****************************************************************************************************
1031 * AddrComputePrtInfo
1034 * Interface function for ComputePrtInfo
1036 ****************************************************************************************************
1038 ADDR_E_RETURNCODE ADDR_API
AddrComputePrtInfo(
1040 const ADDR_PRT_INFO_INPUT
* pIn
,
1041 ADDR_PRT_INFO_OUTPUT
* pOut
)
1043 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1045 V1::Lib
* pLib
= V1::Lib::GetLib(hLib
);
1049 returnCode
= pLib
->ComputePrtInfo(pIn
, pOut
);
1053 returnCode
= ADDR_ERROR
;
1060 ****************************************************************************************************
1061 * AddrGetMaxAlignments
1064 * Convert maximum alignments
1067 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1068 ****************************************************************************************************
1070 ADDR_E_RETURNCODE ADDR_API
AddrGetMaxAlignments(
1071 ADDR_HANDLE hLib
, ///< address lib handle
1072 ADDR_GET_MAX_ALIGNMENTS_OUTPUT
* pOut
) ///< [out] output structure
1074 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
1076 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1080 returnCode
= pLib
->GetMaxAlignments(pOut
);
1084 returnCode
= ADDR_ERROR
;
1091 ****************************************************************************************************
1092 * AddrGetMaxMetaAlignments
1095 * Convert maximum alignments for metadata
1098 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1099 ****************************************************************************************************
1101 ADDR_E_RETURNCODE ADDR_API
AddrGetMaxMetaAlignments(
1102 ADDR_HANDLE hLib
, ///< address lib handle
1103 ADDR_GET_MAX_ALIGNMENTS_OUTPUT
* pOut
) ///< [out] output structure
1105 Addr::Lib
* pLib
= Lib::GetLib(hLib
);
1107 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1111 returnCode
= pLib
->GetMaxMetaAlignments(pOut
);
1115 returnCode
= ADDR_ERROR
;
1121 ////////////////////////////////////////////////////////////////////////////////////////////////////
1122 // Surface functions for Addr2
1123 ////////////////////////////////////////////////////////////////////////////////////////////////////
1126 ****************************************************************************************************
1127 * Addr2ComputeSurfaceInfo
1130 * Calculate surface width/height/depth/alignments and suitable tiling mode
1133 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1134 ****************************************************************************************************
1136 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceInfo(
1137 ADDR_HANDLE hLib
, ///< address lib handle
1138 const ADDR2_COMPUTE_SURFACE_INFO_INPUT
* pIn
, ///< [in] surface information
1139 ADDR2_COMPUTE_SURFACE_INFO_OUTPUT
* pOut
) ///< [out] surface parameters and alignments
1141 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1143 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1147 returnCode
= pLib
->ComputeSurfaceInfo(pIn
, pOut
);
1151 returnCode
= ADDR_ERROR
;
1158 ****************************************************************************************************
1159 * Addr2ComputeSurfaceAddrFromCoord
1162 * Compute surface address according to coordinates
1165 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1166 ****************************************************************************************************
1168 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceAddrFromCoord(
1169 ADDR_HANDLE hLib
, ///< address lib handle
1170 const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] surface info and coordinates
1171 ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] surface address
1173 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1175 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1179 returnCode
= pLib
->ComputeSurfaceAddrFromCoord(pIn
, pOut
);
1183 returnCode
= ADDR_ERROR
;
1190 ****************************************************************************************************
1191 * Addr2ComputeSurfaceCoordFromAddr
1194 * Compute coordinates according to surface address
1197 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1198 ****************************************************************************************************
1200 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSurfaceCoordFromAddr(
1201 ADDR_HANDLE hLib
, ///< address lib handle
1202 const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT
* pIn
, ///< [in] surface info and address
1203 ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] coordinates
1205 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1207 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1211 returnCode
= pLib
->ComputeSurfaceCoordFromAddr(pIn
, pOut
);
1215 returnCode
= ADDR_ERROR
;
1221 ////////////////////////////////////////////////////////////////////////////////////////////////////
1222 // HTile functions for Addr2
1223 ////////////////////////////////////////////////////////////////////////////////////////////////////
1226 ****************************************************************************************************
1227 * Addr2ComputeHtileInfo
1230 * Compute Htile pitch, height, base alignment and size in bytes
1233 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1234 ****************************************************************************************************
1236 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileInfo(
1237 ADDR_HANDLE hLib
, ///< address lib handle
1238 const ADDR2_COMPUTE_HTILE_INFO_INPUT
* pIn
, ///< [in] Htile information
1239 ADDR2_COMPUTE_HTILE_INFO_OUTPUT
* pOut
) ///< [out] Htile pitch, height and size in bytes
1241 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1243 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1247 returnCode
= pLib
->ComputeHtileInfo(pIn
, pOut
);
1251 returnCode
= ADDR_ERROR
;
1258 ****************************************************************************************************
1259 * Addr2ComputeHtileAddrFromCoord
1262 * Compute Htile address according to coordinates (of depth buffer)
1265 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1266 ****************************************************************************************************
1268 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileAddrFromCoord(
1269 ADDR_HANDLE hLib
, ///< address lib handle
1270 const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Htile info and coordinates
1271 ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Htile address
1273 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1275 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1279 returnCode
= pLib
->ComputeHtileAddrFromCoord(pIn
, pOut
);
1283 returnCode
= ADDR_ERROR
;
1290 ****************************************************************************************************
1291 * Addr2ComputeHtileCoordFromAddr
1294 * Compute coordinates within depth buffer (1st pixel of a micro tile) according to
1298 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1299 ****************************************************************************************************
1301 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeHtileCoordFromAddr(
1302 ADDR_HANDLE hLib
, ///< address lib handle
1303 const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT
* pIn
, ///< [in] Htile info and address
1304 ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Htile coordinates
1306 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1308 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1312 returnCode
= pLib
->ComputeHtileCoordFromAddr(pIn
, pOut
);
1316 returnCode
= ADDR_ERROR
;
1322 ////////////////////////////////////////////////////////////////////////////////////////////////////
1323 // C-mask functions for Addr2
1324 ////////////////////////////////////////////////////////////////////////////////////////////////////
1327 ****************************************************************************************************
1328 * Addr2ComputeCmaskInfo
1331 * Compute Cmask pitch, height, base alignment and size in bytes from color buffer
1335 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1336 ****************************************************************************************************
1338 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskInfo(
1339 ADDR_HANDLE hLib
, ///< address lib handle
1340 const ADDR2_COMPUTE_CMASK_INFO_INPUT
* pIn
, ///< [in] Cmask pitch and height
1341 ADDR2_COMPUTE_CMASK_INFO_OUTPUT
* pOut
) ///< [out] Cmask pitch, height and size in bytes
1343 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1345 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1349 returnCode
= pLib
->ComputeCmaskInfo(pIn
, pOut
);
1353 returnCode
= ADDR_ERROR
;
1360 ****************************************************************************************************
1361 * Addr2ComputeCmaskAddrFromCoord
1364 * Compute Cmask address according to coordinates (of MSAA color buffer)
1367 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1368 ****************************************************************************************************
1370 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskAddrFromCoord(
1371 ADDR_HANDLE hLib
, ///< address lib handle
1372 const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Cmask info and coordinates
1373 ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Cmask address
1375 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1377 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1381 returnCode
= pLib
->ComputeCmaskAddrFromCoord(pIn
, pOut
);
1385 returnCode
= ADDR_ERROR
;
1392 ****************************************************************************************************
1393 * Addr2ComputeCmaskCoordFromAddr
1396 * Compute coordinates within color buffer (1st pixel of a micro tile) according to
1400 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1401 ****************************************************************************************************
1403 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeCmaskCoordFromAddr(
1404 ADDR_HANDLE hLib
, ///< address lib handle
1405 const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Cmask info and address
1406 ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Cmask coordinates
1408 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1410 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1414 returnCode
= pLib
->ComputeCmaskCoordFromAddr(pIn
, pOut
);
1418 returnCode
= ADDR_ERROR
;
1424 ////////////////////////////////////////////////////////////////////////////////////////////////////
1425 // F-mask functions for Addr2
1426 ////////////////////////////////////////////////////////////////////////////////////////////////////
1429 ****************************************************************************************************
1430 * Addr2ComputeFmaskInfo
1433 * Compute Fmask pitch/height/depth/alignments and size in bytes
1436 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1437 ****************************************************************************************************
1439 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskInfo(
1440 ADDR_HANDLE hLib
, ///< address lib handle
1441 const ADDR2_COMPUTE_FMASK_INFO_INPUT
* pIn
, ///< [in] Fmask information
1442 ADDR2_COMPUTE_FMASK_INFO_OUTPUT
* pOut
) ///< [out] Fmask pitch and height
1444 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1446 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1450 returnCode
= pLib
->ComputeFmaskInfo(pIn
, pOut
);
1454 returnCode
= ADDR_ERROR
;
1461 ****************************************************************************************************
1462 * Addr2ComputeFmaskAddrFromCoord
1465 * Compute Fmask address according to coordinates (x,y,slice,sample,plane)
1468 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1469 ****************************************************************************************************
1471 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskAddrFromCoord(
1472 ADDR_HANDLE hLib
, ///< address lib handle
1473 const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Fmask info and coordinates
1474 ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Fmask address
1476 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1478 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1482 returnCode
= pLib
->ComputeFmaskAddrFromCoord(pIn
, pOut
);
1486 returnCode
= ADDR_ERROR
;
1493 ****************************************************************************************************
1494 * Addr2ComputeFmaskCoordFromAddr
1497 * Compute coordinates (x,y,slice,sample,plane) according to Fmask address
1500 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1501 ****************************************************************************************************
1503 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeFmaskCoordFromAddr(
1504 ADDR_HANDLE hLib
, ///< address lib handle
1505 const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT
* pIn
, ///< [in] Fmask info and address
1506 ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
* pOut
) ///< [out] Fmask coordinates
1508 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1510 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1514 returnCode
= pLib
->ComputeFmaskCoordFromAddr(pIn
, pOut
);
1518 returnCode
= ADDR_ERROR
;
1524 ////////////////////////////////////////////////////////////////////////////////////////////////////
1525 // DCC key functions for Addr2
1526 ////////////////////////////////////////////////////////////////////////////////////////////////////
1529 ****************************************************************************************************
1530 * Addr2ComputeDccInfo
1533 * Compute DCC key size, base alignment based on color surface size, tile info or tile index
1535 ****************************************************************************************************
1537 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeDccInfo(
1538 ADDR_HANDLE hLib
, ///< handle of addrlib
1539 const ADDR2_COMPUTE_DCCINFO_INPUT
* pIn
, ///< [in] input
1540 ADDR2_COMPUTE_DCCINFO_OUTPUT
* pOut
) ///< [out] output
1542 ADDR_E_RETURNCODE returnCode
;
1544 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1548 returnCode
= pLib
->ComputeDccInfo(pIn
, pOut
);
1552 returnCode
= ADDR_ERROR
;
1559 ****************************************************************************************************
1560 * Addr2ComputeDccAddrFromCoord
1563 * Compute DCC key address according to coordinates
1566 * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
1567 ****************************************************************************************************
1569 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeDccAddrFromCoord(
1570 ADDR_HANDLE hLib
, ///< address lib handle
1571 const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
* pIn
, ///< [in] Dcc info and coordinates
1572 ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
* pOut
) ///< [out] Dcc address
1574 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1576 ADDR_E_RETURNCODE returnCode
= ADDR_OK
;
1580 returnCode
= pLib
->ComputeDccAddrFromCoord(pIn
, pOut
);
1584 returnCode
= ADDR_ERROR
;
1591 ****************************************************************************************************
1592 * Addr2ComputePipeBankXor
1595 * Calculate a valid bank pipe xor value for client to use.
1596 ****************************************************************************************************
1598 ADDR_E_RETURNCODE ADDR_API
Addr2ComputePipeBankXor(
1599 ADDR_HANDLE hLib
, ///< handle of addrlib
1600 const ADDR2_COMPUTE_PIPEBANKXOR_INPUT
* pIn
, ///< [in] input
1601 ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT
* pOut
) ///< [out] output
1603 ADDR_E_RETURNCODE returnCode
;
1605 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1609 returnCode
= pLib
->ComputePipeBankXor(pIn
, pOut
);
1613 returnCode
= ADDR_ERROR
;
1620 ****************************************************************************************************
1621 * Addr2ComputeSlicePipeBankXor
1624 * Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
1625 ****************************************************************************************************
1627 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSlicePipeBankXor(
1628 ADDR_HANDLE hLib
, ///< handle of addrlib
1629 const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
* pIn
, ///< [in] input
1630 ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
* pOut
) ///< [out] output
1632 ADDR_E_RETURNCODE returnCode
;
1634 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1638 returnCode
= pLib
->ComputeSlicePipeBankXor(pIn
, pOut
);
1642 returnCode
= ADDR_ERROR
;
1649 ****************************************************************************************************
1650 * Addr2ComputeSubResourceOffsetForSwizzlePattern
1653 * Calculate sub resource offset for swizzle pattern.
1654 ****************************************************************************************************
1656 ADDR_E_RETURNCODE ADDR_API
Addr2ComputeSubResourceOffsetForSwizzlePattern(
1657 ADDR_HANDLE hLib
, ///< handle of addrlib
1658 const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
* pIn
, ///< [in] input
1659 ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
* pOut
) ///< [out] output
1661 ADDR_E_RETURNCODE returnCode
;
1663 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1667 returnCode
= pLib
->ComputeSubResourceOffsetForSwizzlePattern(pIn
, pOut
);
1671 returnCode
= ADDR_ERROR
;
1678 ****************************************************************************************************
1679 * Addr2GetPreferredSurfaceSetting
1682 * Suggest a preferred setting for client driver to program HW register
1683 ****************************************************************************************************
1685 ADDR_E_RETURNCODE ADDR_API
Addr2GetPreferredSurfaceSetting(
1686 ADDR_HANDLE hLib
, ///< handle of addrlib
1687 const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT
* pIn
, ///< [in] input
1688 ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT
* pOut
) ///< [out] output
1690 ADDR_E_RETURNCODE returnCode
;
1692 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1696 returnCode
= pLib
->Addr2GetPreferredSurfaceSetting(pIn
, pOut
);
1700 returnCode
= ADDR_ERROR
;
1707 ****************************************************************************************************
1708 * Addr2IsValidDisplaySwizzleMode
1711 * Return whether the swizzle mode is supported by DCE / DCN.
1712 ****************************************************************************************************
1714 ADDR_E_RETURNCODE ADDR_API
Addr2IsValidDisplaySwizzleMode(
1716 AddrSwizzleMode swizzleMode
,
1720 ADDR_E_RETURNCODE returnCode
;
1722 V2::Lib
* pLib
= V2::Lib::GetLib(hLib
);
1726 ADDR2_COMPUTE_SURFACE_INFO_INPUT in
;
1727 in
.resourceType
= ADDR_RSRC_TEX_2D
;
1728 in
.swizzleMode
= swizzleMode
;
1731 *result
= pLib
->IsValidDisplaySwizzleMode(&in
);
1732 returnCode
= ADDR_OK
;
1736 returnCode
= ADDR_ERROR
;