| /* |
| * Copyright © 2014 Advanced Micro Devices, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining |
| * a copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES |
| * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS |
| * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
| * USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| */ |
| |
| /** |
| *************************************************************************************************** |
| * @file addrinterface.cpp |
| * @brief Contains the addrlib interface functions |
| *************************************************************************************************** |
| */ |
| #include "addrinterface.h" |
| #include "addrlib.h" |
| |
| #include "addrcommon.h" |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Create/Destroy/Config functions |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| *************************************************************************************************** |
| * AddrCreate |
| * |
| * @brief |
| * Create address lib object |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrCreate( |
| const ADDR_CREATE_INPUT* pAddrCreateIn, ///< [in] infomation for creating address lib object |
| ADDR_CREATE_OUTPUT* pAddrCreateOut) ///< [out] address lib handle |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| returnCode = AddrLib::Create(pAddrCreateIn, pAddrCreateOut); |
| |
| return returnCode; |
| } |
| |
| |
| |
| /** |
| *************************************************************************************************** |
| * AddrDestroy |
| * |
| * @brief |
| * Destroy address lib object |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrDestroy( |
| ADDR_HANDLE hLib) ///< [in] address lib handle |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (hLib) |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| pLib->Destroy(); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // Surface functions |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeSurfaceInfo |
| * |
| * @brief |
| * Calculate surface width/height/depth/alignments and suitable tiling mode |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information |
| ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeSurfaceInfo(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeSurfaceAddrFromCoord |
| * |
| * @brief |
| * Compute surface address according to coordinates |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates |
| ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeSurfaceCoordFromAddr |
| * |
| * @brief |
| * Compute coordinates according to surface address |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address |
| ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // HTile functions |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeHtileInfo |
| * |
| * @brief |
| * Compute Htile pitch, height, base alignment and size in bytes |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information |
| ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeHtileInfo(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeHtileAddrFromCoord |
| * |
| * @brief |
| * Compute Htile address according to coordinates (of depth buffer) |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates |
| ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeHtileCoordFromAddr |
| * |
| * @brief |
| * Compute coordinates within depth buffer (1st pixel of a micro tile) according to |
| * Htile address |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address |
| ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // C-mask functions |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeCmaskInfo |
| * |
| * @brief |
| * Compute Cmask pitch, height, base alignment and size in bytes from color buffer |
| * info |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height |
| ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeCmaskInfo(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeCmaskAddrFromCoord |
| * |
| * @brief |
| * Compute Cmask address according to coordinates (of MSAA color buffer) |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates |
| ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeCmaskCoordFromAddr |
| * |
| * @brief |
| * Compute coordinates within color buffer (1st pixel of a micro tile) according to |
| * Cmask address |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address |
| ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // F-mask functions |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeFmaskInfo |
| * |
| * @brief |
| * Compute Fmask pitch/height/depth/alignments and size in bytes |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information |
| ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeFmaskInfo(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeFmaskAddrFromCoord |
| * |
| * @brief |
| * Compute Fmask address according to coordinates (x,y,slice,sample,plane) |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates |
| ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeFmaskCoordFromAddr |
| * |
| * @brief |
| * Compute coordinates (x,y,slice,sample,plane) according to Fmask address |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address |
| ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| // DCC key functions |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeDccInfo |
| * |
| * @brief |
| * Compute DCC key size, base alignment based on color surface size, tile info or tile index |
| * |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo( |
| ADDR_HANDLE hLib, ///< [in] handle of addrlib |
| const ADDR_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input |
| ADDR_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output |
| { |
| ADDR_E_RETURNCODE returnCode; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeDccInfo(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Below functions are element related or helper functions |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| *************************************************************************************************** |
| * AddrGetVersion |
| * |
| * @brief |
| * Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION |
| * defined in addrinterface.h to see if there is a mismatch. |
| *************************************************************************************************** |
| */ |
| UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib) |
| { |
| UINT_32 version = 0; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_ASSERT(pLib != NULL); |
| |
| if (pLib) |
| { |
| version = pLib->GetVersion(); |
| } |
| |
| return version; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrUseTileIndex |
| * |
| * @brief |
| * Return TRUE if tileIndex is enabled in this address library |
| *************************************************************************************************** |
| */ |
| BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib) |
| { |
| BOOL_32 useTileIndex = FALSE; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_ASSERT(pLib != NULL); |
| |
| if (pLib) |
| { |
| useTileIndex = pLib->UseTileIndex(0); |
| } |
| |
| return useTileIndex; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrUseCombinedSwizzle |
| * |
| * @brief |
| * Return TRUE if combined swizzle is enabled in this address library |
| *************************************************************************************************** |
| */ |
| BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib) |
| { |
| BOOL_32 useCombinedSwizzle = FALSE; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_ASSERT(pLib != NULL); |
| |
| if (pLib) |
| { |
| useCombinedSwizzle = pLib->UseCombinedSwizzle(); |
| } |
| |
| return useCombinedSwizzle; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrExtractBankPipeSwizzle |
| * |
| * @brief |
| * Extract Bank and Pipe swizzle from base256b |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle( |
| ADDR_HANDLE hLib, ///< [in] addrlib handle |
| const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure |
| ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) ///< [out] output structure |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ExtractBankPipeSwizzle(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrCombineBankPipeSwizzle |
| * |
| * @brief |
| * Combine Bank and Pipe swizzle |
| * @return |
| * ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle( |
| ADDR_HANDLE hLib, |
| const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn, |
| ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut) |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->CombineBankPipeSwizzle(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeSliceSwizzle |
| * |
| * @brief |
| * Compute a swizzle for slice from a base swizzle |
| * @return |
| * ADDR_OK if no error |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle( |
| ADDR_HANDLE hLib, |
| const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, |
| ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut) |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeSliceTileSwizzle(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputeBaseSwizzle |
| * |
| * @brief |
| * Return a Combined Bank and Pipe swizzle base on surface based on surface type/index |
| * @return |
| * ADDR_OK if no error |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle( |
| ADDR_HANDLE hLib, |
| const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn, |
| ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut) |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputeBaseSwizzle(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * ElemFlt32ToDepthPixel |
| * |
| * @brief |
| * Convert a FLT_32 value to a depth/stencil pixel value |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| * |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel( |
| ADDR_HANDLE hLib, ///< [in] addrlib handle |
| const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn, ///< [in] per-component value |
| ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) ///< [out] final pixel value |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| pLib->Flt32ToDepthPixel(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * ElemFlt32ToColorPixel |
| * |
| * @brief |
| * Convert a FLT_32 value to a red/green/blue/alpha pixel value |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| * |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel( |
| ADDR_HANDLE hLib, ///< [in] addrlib handle |
| const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn, ///< [in] format, surface number and swap value |
| ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) ///< [out] final pixel value |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| pLib->Flt32ToColorPixel(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * ElemGetExportNorm |
| * |
| * @brief |
| * Helper function to check one format can be EXPORT_NUM, |
| * which is a register CB_COLOR_INFO.SURFACE_FORMAT. |
| * FP16 can be reported as EXPORT_NORM for rv770 in r600 |
| * family |
| * |
| *************************************************************************************************** |
| */ |
| BOOL_32 ADDR_API ElemGetExportNorm( |
| ADDR_HANDLE hLib, ///< [in] addrlib handle |
| const ELEM_GETEXPORTNORM_INPUT* pIn) ///< [in] input structure |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| BOOL_32 enabled = FALSE; |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| enabled = pLib->GetExportNorm(pIn); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| ADDR_ASSERT(returnCode == ADDR_OK); |
| |
| return enabled; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrConvertTileInfoToHW |
| * |
| * @brief |
| * Convert tile info from real value to hardware register value |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] tile info with real value |
| ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) ///< [out] tile info with HW register value |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ConvertTileInfoToHW(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrConvertTileIndex |
| * |
| * @brief |
| * Convert tile index to tile mode/type/info |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input - tile index |
| ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ConvertTileIndex(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrConvertTileIndex1 |
| * |
| * @brief |
| * Convert tile index to tile mode/type/info |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1( |
| ADDR_HANDLE hLib, ///< [in] address lib handle |
| const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input - tile index |
| ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ConvertTileIndex1(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrGetTileIndex |
| * |
| * @brief |
| * Get tile index from tile mode/type/info |
| * |
| * @return |
| * ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE |
| * |
| * @note |
| * Only meaningful for SI (and above) |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex( |
| ADDR_HANDLE hLib, |
| const ADDR_GET_TILEINDEX_INPUT* pIn, |
| ADDR_GET_TILEINDEX_OUTPUT* pOut) |
| { |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->GetTileIndex(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |
| /** |
| *************************************************************************************************** |
| * AddrComputePrtInfo |
| * |
| * @brief |
| * Interface function for ComputePrtInfo |
| * |
| *************************************************************************************************** |
| */ |
| ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo( |
| ADDR_HANDLE hLib, |
| const ADDR_PRT_INFO_INPUT* pIn, |
| ADDR_PRT_INFO_OUTPUT* pOut) |
| { |
| ADDR_E_RETURNCODE returnCode = ADDR_OK; |
| |
| AddrLib* pLib = AddrLib::GetAddrLib(hLib); |
| |
| if (pLib != NULL) |
| { |
| returnCode = pLib->ComputePrtInfo(pIn, pOut); |
| } |
| else |
| { |
| returnCode = ADDR_ERROR; |
| } |
| |
| return returnCode; |
| } |
| |