/* * 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; }