amd/addrlib: update Mesa's copy of addrlib
authorNicolai Hähnle <nicolai.haehnle@amd.com>
Mon, 19 Nov 2018 17:53:09 +0000 (18:53 +0100)
committerNicolai Hähnle <nicolai.haehnle@amd.com>
Thu, 29 Nov 2018 12:18:24 +0000 (13:18 +0100)
Update to the internal master as of 2018-11-15.

This has a lot of gratuitous whitespace change, but on the plus
side it's built using the same tooling that's used for AMDVLK,
which should help going forward.

63 files changed:
src/amd/Makefile.addrlib.am
src/amd/Makefile.sources
src/amd/addrlib/addrinterface.cpp [deleted file]
src/amd/addrlib/addrinterface.h [deleted file]
src/amd/addrlib/addrtypes.h [deleted file]
src/amd/addrlib/amdgpu_asic_addr.h [deleted file]
src/amd/addrlib/core/addrcommon.h [deleted file]
src/amd/addrlib/core/addrelemlib.cpp [deleted file]
src/amd/addrlib/core/addrelemlib.h [deleted file]
src/amd/addrlib/core/addrlib.cpp [deleted file]
src/amd/addrlib/core/addrlib.h [deleted file]
src/amd/addrlib/core/addrlib1.cpp [deleted file]
src/amd/addrlib/core/addrlib1.h [deleted file]
src/amd/addrlib/core/addrlib2.cpp [deleted file]
src/amd/addrlib/core/addrlib2.h [deleted file]
src/amd/addrlib/core/addrobject.cpp [deleted file]
src/amd/addrlib/core/addrobject.h [deleted file]
src/amd/addrlib/gfx9/chip/gfx9_enum.h [deleted file]
src/amd/addrlib/gfx9/coord.cpp [deleted file]
src/amd/addrlib/gfx9/coord.h [deleted file]
src/amd/addrlib/gfx9/gfx9addrlib.cpp [deleted file]
src/amd/addrlib/gfx9/gfx9addrlib.h [deleted file]
src/amd/addrlib/inc/addrinterface.h [new file with mode: 0644]
src/amd/addrlib/inc/addrtypes.h [new file with mode: 0644]
src/amd/addrlib/inc/chip/gfx9/gfx9_gb_reg.h [deleted file]
src/amd/addrlib/inc/chip/r800/si_gb_reg.h [deleted file]
src/amd/addrlib/meson.build
src/amd/addrlib/r800/chip/si_ci_vi_merged_enum.h [deleted file]
src/amd/addrlib/r800/ciaddrlib.cpp [deleted file]
src/amd/addrlib/r800/ciaddrlib.h [deleted file]
src/amd/addrlib/r800/egbaddrlib.cpp [deleted file]
src/amd/addrlib/r800/egbaddrlib.h [deleted file]
src/amd/addrlib/r800/siaddrlib.cpp [deleted file]
src/amd/addrlib/r800/siaddrlib.h [deleted file]
src/amd/addrlib/src/addrinterface.cpp [new file with mode: 0644]
src/amd/addrlib/src/amdgpu_asic_addr.h [new file with mode: 0644]
src/amd/addrlib/src/chip/gfx9/gfx9_gb_reg.h [new file with mode: 0644]
src/amd/addrlib/src/chip/r800/si_gb_reg.h [new file with mode: 0644]
src/amd/addrlib/src/core/addrcommon.h [new file with mode: 0644]
src/amd/addrlib/src/core/addrelemlib.cpp [new file with mode: 0644]
src/amd/addrlib/src/core/addrelemlib.h [new file with mode: 0644]
src/amd/addrlib/src/core/addrlib.cpp [new file with mode: 0644]
src/amd/addrlib/src/core/addrlib.h [new file with mode: 0644]
src/amd/addrlib/src/core/addrlib1.cpp [new file with mode: 0644]
src/amd/addrlib/src/core/addrlib1.h [new file with mode: 0644]
src/amd/addrlib/src/core/addrlib2.cpp [new file with mode: 0644]
src/amd/addrlib/src/core/addrlib2.h [new file with mode: 0644]
src/amd/addrlib/src/core/addrobject.cpp [new file with mode: 0644]
src/amd/addrlib/src/core/addrobject.h [new file with mode: 0644]
src/amd/addrlib/src/core/coord.cpp [new file with mode: 0644]
src/amd/addrlib/src/core/coord.h [new file with mode: 0644]
src/amd/addrlib/src/gfx9/gfx9addrlib.cpp [new file with mode: 0644]
src/amd/addrlib/src/gfx9/gfx9addrlib.h [new file with mode: 0644]
src/amd/addrlib/src/r800/ciaddrlib.cpp [new file with mode: 0644]
src/amd/addrlib/src/r800/ciaddrlib.h [new file with mode: 0644]
src/amd/addrlib/src/r800/egbaddrlib.cpp [new file with mode: 0644]
src/amd/addrlib/src/r800/egbaddrlib.h [new file with mode: 0644]
src/amd/addrlib/src/r800/siaddrlib.cpp [new file with mode: 0644]
src/amd/addrlib/src/r800/siaddrlib.h [new file with mode: 0644]
src/amd/common/ac_surface.c
src/amd/vulkan/winsys/amdgpu/radv_amdgpu_surface.c
src/amd/vulkan/winsys/amdgpu/radv_amdgpu_winsys.h
src/gallium/winsys/amdgpu/drm/amdgpu_winsys.h

index af0daf907d54fa108a55ddf42544ce17d9dba383..6de0e487f69e71e960d7554e6406e66cef2e95b7 100644 (file)
@@ -26,12 +26,11 @@ addrlib_libamdgpu_addrlib_la_CPPFLAGS = \
        -I$(top_srcdir)/src/ \
        -I$(top_srcdir)/include \
        -I$(srcdir)/common \
-       -I$(srcdir)/addrlib \
-       -I$(srcdir)/addrlib/core \
-       -I$(srcdir)/addrlib/inc/chip/gfx9 \
-       -I$(srcdir)/addrlib/inc/chip/r800 \
-       -I$(srcdir)/addrlib/gfx9/chip \
-       -I$(srcdir)/addrlib/r800/chip
+       -I$(srcdir)/addrlib/inc \
+       -I$(srcdir)/addrlib/src \
+       -I$(srcdir)/addrlib/src/core \
+       -I$(srcdir)/addrlib/src/chip/gfx9 \
+       -I$(srcdir)/addrlib/src/chip/r800
 
 addrlib_libamdgpu_addrlib_la_CXXFLAGS = \
        $(VISIBILITY_CXXFLAGS) $(CXX11_CXXFLAGS)
index 41334cb98189ecabcb5bc854d4d6adbb7fc8684d..49d1031874a079063d4da4bb55ec8d453279c9f4 100644 (file)
@@ -5,35 +5,34 @@ COMMON_HEADER_FILES = \
        common/amd_kernel_code_t.h
 
 ADDRLIB_FILES = \
-       addrlib/addrinterface.cpp \
-       addrlib/addrinterface.h \
-       addrlib/addrtypes.h \
-       addrlib/amdgpu_asic_addr.h \
-       addrlib/core/addrcommon.h \
-       addrlib/core/addrelemlib.cpp \
-       addrlib/core/addrelemlib.h \
-       addrlib/core/addrlib.cpp \
-       addrlib/core/addrlib.h \
-       addrlib/core/addrlib1.cpp \
-       addrlib/core/addrlib1.h \
-       addrlib/core/addrlib2.cpp \
-       addrlib/core/addrlib2.h \
-       addrlib/core/addrobject.cpp \
-       addrlib/core/addrobject.h \
-       addrlib/gfx9/chip/gfx9_enum.h \
-       addrlib/gfx9/coord.cpp \
-       addrlib/gfx9/coord.h \
-       addrlib/gfx9/gfx9addrlib.cpp \
-       addrlib/gfx9/gfx9addrlib.h \
-       addrlib/inc/chip/gfx9/gfx9_gb_reg.h \
-       addrlib/inc/chip/r800/si_gb_reg.h \
-       addrlib/r800/chip/si_ci_vi_merged_enum.h \
-       addrlib/r800/ciaddrlib.cpp \
-       addrlib/r800/ciaddrlib.h \
-       addrlib/r800/egbaddrlib.cpp \
-       addrlib/r800/egbaddrlib.h \
-       addrlib/r800/siaddrlib.cpp \
-       addrlib/r800/siaddrlib.h
+       addrlib/inc/addrinterface.h \
+       addrlib/inc/addrtypes.h \
+       addrlib/src/addrinterface.cpp \
+       addrlib/src/amdgpu_asic_addr.h \
+       addrlib/src/core/addrcommon.h \
+       addrlib/src/core/addrelemlib.cpp \
+       addrlib/src/core/addrelemlib.h \
+       addrlib/src/core/addrlib.cpp \
+       addrlib/src/core/addrlib.h \
+       addrlib/src/core/addrlib1.cpp \
+       addrlib/src/core/addrlib1.h \
+       addrlib/src/core/addrlib2.cpp \
+       addrlib/src/core/addrlib2.h \
+       addrlib/src/core/addrobject.cpp \
+       addrlib/src/core/addrobject.h \
+       addrlib/src/core/coord.cpp \
+       addrlib/src/core/coord.h \
+       addrlib/src/gfx9/gfx9addrlib.cpp \
+       addrlib/src/gfx9/gfx9addrlib.h \
+       addrlib/src/chip/gfx9/gfx9_gb_reg.h \
+       addrlib/src/chip/r800/si_gb_reg.h \
+       addrlib/src/r800/chip/si_ci_vi_merged_enum.h \
+       addrlib/src/r800/ciaddrlib.cpp \
+       addrlib/src/r800/ciaddrlib.h \
+       addrlib/src/r800/egbaddrlib.cpp \
+       addrlib/src/r800/egbaddrlib.h \
+       addrlib/src/r800/siaddrlib.cpp \
+       addrlib/src/r800/siaddrlib.h
 
 AMD_COMPILER_FILES = \
        common/ac_binary.c \
diff --git a/src/amd/addrlib/addrinterface.cpp b/src/amd/addrlib/addrinterface.cpp
deleted file mode 100644 (file)
index 9cbeba4..0000000
+++ /dev/null
@@ -1,1743 +0,0 @@
-/*
- * 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 "addrlib1.h"
-#include "addrlib2.h"
-
-#include "addrcommon.h"
-
-#include "util/macros.h"
-
-using namespace Addr;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                               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 = Lib::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) ///< address lib handle
-{
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (hLib)
-    {
-        Lib* pLib = Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,  ///< [in] surface information
-    ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut) ///< [out] surface parameters and alignments
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,  ///< [in] surface info and coordinates
-    ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut) ///< [out] surface address
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,  ///< [in] surface info and address
-    ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut) ///< [out] coordinates
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< 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
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Htile info and coordinates
-    ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Htile address
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,  ///< [in] Htile info and address
-    ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Htile coordinates
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< 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
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Cmask info and coordinates
-    ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Cmask address
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Cmask info and address
-    ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Cmask coordinates
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,  ///< [in] Fmask information
-    ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut) ///< [out] Fmask pitch and height
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,  ///< [in] Fmask info and coordinates
-    ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut) ///< [out] Fmask address
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,  ///< [in] Fmask info and address
-    ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut) ///< [out] Fmask coordinates
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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,   ///< handle of addrlib
-    const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,    ///< [in] input
-    ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut)   ///< [out] output
-{
-    ADDR_E_RETURNCODE returnCode;
-
-    V1::Lib* pLib = V1::Lib::GetLib(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;
-
-    Addr::Lib* pLib = Lib::GetLib(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;
-
-    V1::Lib* pLib = V1::Lib::GetLib(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;
-
-    V1::Lib* pLib = V1::Lib::GetLib(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,     ///< 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;
-
-    V1::Lib* pLib = V1::Lib::GetLib(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;
-
-    V1::Lib* pLib = V1::Lib::GetLib(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;
-
-    V1::Lib* pLib = V1::Lib::GetLib(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;
-
-    V1::Lib* pLib = V1::Lib::GetLib(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,    ///< 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;
-
-    Lib* pLib = Lib::GetLib(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,    ///< 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;
-
-    Lib* pLib = Lib::GetLib(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, ///< addrlib handle
-    const ELEM_GETEXPORTNORM_INPUT* pIn)  ///< [in] input structure
-{
-    Addr::Lib* pLib = Lib::GetLib(hLib);
-    BOOL_32 enabled = FALSE;
-
-    MAYBE_UNUSED 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, ///< 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
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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, ///< address lib handle
-    const ADDR_CONVERT_TILEINDEX_INPUT*  pIn,  ///< [in] input - tile index
-    ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
-{
-    V1::Lib* pLib = V1::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ConvertTileIndex(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   AddrGetMacroModeIndex
-*
-*   @brief
-*       Get macro mode index based on input parameters
-*
-*   @return
-*       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
-    ADDR_HANDLE                          hLib, ///< address lib handle
-    const ADDR_GET_MACROMODEINDEX_INPUT* pIn,  ///< [in] input
-    ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut) ///< [out] macro mode index
-{
-    V1::Lib* pLib = V1::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->GetMacroModeIndex(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, ///< address lib handle
-    const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,  ///< [in] input - tile index
-    ADDR_CONVERT_TILEINDEX_OUTPUT*       pOut) ///< [out] tile mode/type/info
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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)
-{
-    V1::Lib* pLib = V1::Lib::GetLib(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;
-
-    V1::Lib* pLib = V1::Lib::GetLib(hLib);
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputePrtInfo(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   AddrGetMaxAlignments
-*
-*   @brief
-*       Convert maximum alignments
-*
-*   @return
-*       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
-    ADDR_HANDLE                     hLib, ///< address lib handle
-    ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) ///< [out] output structure
-{
-    Addr::Lib* pLib = Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->GetMaxAlignments(pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   AddrGetMaxMetaAlignments
-*
-*   @brief
-*       Convert maximum alignments for metadata
-*
-*   @return
-*       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrGetMaxMetaAlignments(
-    ADDR_HANDLE                     hLib, ///< address lib handle
-    ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut) ///< [out] output structure
-{
-    Addr::Lib* pLib = Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->GetMaxMetaAlignments(pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                    Surface functions for Addr2
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSurfaceInfo
-*
-*   @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 Addr2ComputeSurfaceInfo(
-    ADDR_HANDLE                                hLib, ///< address lib handle
-    const ADDR2_COMPUTE_SURFACE_INFO_INPUT*    pIn,  ///< [in] surface information
-    ADDR2_COMPUTE_SURFACE_INFO_OUTPUT*         pOut) ///< [out] surface parameters and alignments
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeSurfaceInfo(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSurfaceAddrFromCoord
-*
-*   @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 Addr2ComputeSurfaceAddrFromCoord(
-    ADDR_HANDLE                                         hLib, ///< address lib handle
-    const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] surface info and coordinates
-    ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] surface address
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSurfaceCoordFromAddr
-*
-*   @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 Addr2ComputeSurfaceCoordFromAddr(
-    ADDR_HANDLE                                         hLib, ///< address lib handle
-    const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT*    pIn,  ///< [in] surface info and address
-    ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*         pOut) ///< [out] coordinates
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                   HTile functions for Addr2
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   Addr2ComputeHtileInfo
-*
-*   @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 Addr2ComputeHtileInfo(
-    ADDR_HANDLE                              hLib, ///< address lib handle
-    const ADDR2_COMPUTE_HTILE_INFO_INPUT*    pIn,  ///< [in] Htile information
-    ADDR2_COMPUTE_HTILE_INFO_OUTPUT*         pOut) ///< [out] Htile pitch, height and size in bytes
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeHtileInfo(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeHtileAddrFromCoord
-*
-*   @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 Addr2ComputeHtileAddrFromCoord(
-    ADDR_HANDLE                                       hLib, ///< address lib handle
-    const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Htile info and coordinates
-    ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Htile address
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeHtileCoordFromAddr
-*
-*   @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 Addr2ComputeHtileCoordFromAddr(
-    ADDR_HANDLE                                       hLib, ///< address lib handle
-    const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT*    pIn,  ///< [in] Htile info and address
-    ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*         pOut) ///< [out] Htile coordinates
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     C-mask functions for Addr2
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   Addr2ComputeCmaskInfo
-*
-*   @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 Addr2ComputeCmaskInfo(
-    ADDR_HANDLE                              hLib, ///< address lib handle
-    const ADDR2_COMPUTE_CMASK_INFO_INPUT*    pIn,  ///< [in] Cmask pitch and height
-    ADDR2_COMPUTE_CMASK_INFO_OUTPUT*         pOut) ///< [out] Cmask pitch, height and size in bytes
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeCmaskInfo(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeCmaskAddrFromCoord
-*
-*   @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 Addr2ComputeCmaskAddrFromCoord(
-    ADDR_HANDLE                                       hLib, ///< address lib handle
-    const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Cmask info and coordinates
-    ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Cmask address
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeCmaskCoordFromAddr
-*
-*   @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 Addr2ComputeCmaskCoordFromAddr(
-    ADDR_HANDLE                                       hLib, ///< address lib handle
-    const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT*    pIn,  ///< [in] Cmask info and address
-    ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*         pOut) ///< [out] Cmask coordinates
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     F-mask functions for Addr2
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   Addr2ComputeFmaskInfo
-*
-*   @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 Addr2ComputeFmaskInfo(
-    ADDR_HANDLE                              hLib, ///< address lib handle
-    const ADDR2_COMPUTE_FMASK_INFO_INPUT*    pIn,  ///< [in] Fmask information
-    ADDR2_COMPUTE_FMASK_INFO_OUTPUT*         pOut) ///< [out] Fmask pitch and height
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeFmaskInfo(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeFmaskAddrFromCoord
-*
-*   @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 Addr2ComputeFmaskAddrFromCoord(
-    ADDR_HANDLE                                       hLib, ///< address lib handle
-    const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Fmask info and coordinates
-    ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Fmask address
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-/**
-****************************************************************************************************
-*   Addr2ComputeFmaskCoordFromAddr
-*
-*   @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 Addr2ComputeFmaskCoordFromAddr(
-    ADDR_HANDLE                                       hLib, ///< address lib handle
-    const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT*    pIn,  ///< [in] Fmask info and address
-    ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*         pOut) ///< [out] Fmask coordinates
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     DCC key functions for Addr2
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   Addr2ComputeDccInfo
-*
-*   @brief
-*       Compute DCC key size, base alignment based on color surface size, tile info or tile index
-*
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
-    ADDR_HANDLE                           hLib,   ///< handle of addrlib
-    const ADDR2_COMPUTE_DCCINFO_INPUT*    pIn,    ///< [in] input
-    ADDR2_COMPUTE_DCCINFO_OUTPUT*         pOut)   ///< [out] output
-{
-    ADDR_E_RETURNCODE returnCode;
-
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeDccInfo(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   Addr2ComputeDccAddrFromCoord
-*
-*   @brief
-*       Compute DCC key address according to coordinates
-*
-*   @return
-*       ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
-    ADDR_HANDLE                                     hLib, ///< address lib handle
-    const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT*    pIn,  ///< [in] Dcc info and coordinates
-    ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT*         pOut) ///< [out] Dcc address
-{
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    ADDR_E_RETURNCODE returnCode = ADDR_OK;
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeDccAddrFromCoord(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   Addr2ComputePipeBankXor
-*
-*   @brief
-*       Calculate a valid bank pipe xor value for client to use.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
-    ADDR_HANDLE                            hLib, ///< handle of addrlib
-    const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,  ///< [in] input
-    ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT*      pOut) ///< [out] output
-{
-    ADDR_E_RETURNCODE returnCode;
-
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputePipeBankXor(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSlicePipeBankXor
-*
-*   @brief
-*       Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
-    ADDR_HANDLE                                  hLib, ///< handle of addrlib
-    const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,  ///< [in] input
-    ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT*      pOut) ///< [out] output
-{
-    ADDR_E_RETURNCODE returnCode;
-
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeSlicePipeBankXor(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSubResourceOffsetForSwizzlePattern
-*
-*   @brief
-*       Calculate sub resource offset for swizzle pattern.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
-    ADDR_HANDLE                                                     hLib, ///< handle of addrlib
-    const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,  ///< [in] input
-    ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT*      pOut) ///< [out] output
-{
-    ADDR_E_RETURNCODE returnCode;
-
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->ComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   Addr2GetPreferredSurfaceSetting
-*
-*   @brief
-*       Suggest a preferred setting for client driver to program HW register
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
-    ADDR_HANDLE                                   hLib, ///< handle of addrlib
-    const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,  ///< [in] input
-    ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT*      pOut) ///< [out] output
-{
-    ADDR_E_RETURNCODE returnCode;
-
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    if (pLib != NULL)
-    {
-        returnCode = pLib->Addr2GetPreferredSurfaceSetting(pIn, pOut);
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
-
-/**
-****************************************************************************************************
-*   Addr2IsValidDisplaySwizzleMode
-*
-*   @brief
-*       Return whether the swizzle mode is supported by DCE / DCN.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
-    ADDR_HANDLE     hLib,
-    AddrSwizzleMode swizzleMode,
-    UINT_32         bpp,
-    bool            *result)
-{
-    ADDR_E_RETURNCODE returnCode;
-
-    V2::Lib* pLib = V2::Lib::GetLib(hLib);
-
-    if (pLib != NULL)
-    {
-        ADDR2_COMPUTE_SURFACE_INFO_INPUT in;
-        in.swizzleMode = swizzleMode;
-        in.bpp = bpp;
-
-        *result = pLib->IsValidDisplaySwizzleMode(&in);
-        returnCode = ADDR_OK;
-    }
-    else
-    {
-        returnCode = ADDR_ERROR;
-    }
-
-    return returnCode;
-}
diff --git a/src/amd/addrlib/addrinterface.h b/src/amd/addrlib/addrinterface.h
deleted file mode 100644 (file)
index be9e5c2..0000000
+++ /dev/null
@@ -1,3717 +0,0 @@
-/*
- * 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.h
-* @brief Contains the addrlib interfaces declaration and parameter defines
-****************************************************************************************************
-*/
-#ifndef __ADDR_INTERFACE_H__
-#define __ADDR_INTERFACE_H__
-
-#include "addrtypes.h"
-
-#if defined(__cplusplus)
-extern "C"
-{
-#endif
-
-#define ADDRLIB_VERSION_MAJOR 6
-#define ADDRLIB_VERSION_MINOR 2
-#define ADDRLIB_VERSION ((ADDRLIB_VERSION_MAJOR << 16) | ADDRLIB_VERSION_MINOR)
-
-/// Virtually all interface functions need ADDR_HANDLE as first parameter
-typedef VOID*   ADDR_HANDLE;
-
-/// Client handle used in callbacks
-typedef VOID*   ADDR_CLIENT_HANDLE;
-
-/**
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-* //                                  Callback functions
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-*    typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
-*         const ADDR_ALLOCSYSMEM_INPUT* pInput);
-*    typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
-*         VOID* pVirtAddr);
-*    typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
-*         const ADDR_DEBUGPRINT_INPUT* pInput);
-*
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-* //                               Create/Destroy/Config functions
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-*     AddrCreate()
-*     AddrDestroy()
-*
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-* //                                  Surface functions
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-*     AddrComputeSurfaceInfo()
-*     AddrComputeSurfaceAddrFromCoord()
-*     AddrComputeSurfaceCoordFromAddr()
-*
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-* //                                   HTile functions
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-*     AddrComputeHtileInfo()
-*     AddrComputeHtileAddrFromCoord()
-*     AddrComputeHtileCoordFromAddr()
-*
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-* //                                   C-mask functions
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-*     AddrComputeCmaskInfo()
-*     AddrComputeCmaskAddrFromCoord()
-*     AddrComputeCmaskCoordFromAddr()
-*
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-* //                                   F-mask functions
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-*     AddrComputeFmaskInfo()
-*     AddrComputeFmaskAddrFromCoord()
-*     AddrComputeFmaskCoordFromAddr()
-*
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-* //                               Element/Utility functions
-* /////////////////////////////////////////////////////////////////////////////////////////////////
-*     ElemFlt32ToDepthPixel()
-*     ElemFlt32ToColorPixel()
-*     AddrExtractBankPipeSwizzle()
-*     AddrCombineBankPipeSwizzle()
-*     AddrComputeSliceSwizzle()
-*     AddrConvertTileInfoToHW()
-*     AddrConvertTileIndex()
-*     AddrConvertTileIndex1()
-*     AddrGetTileIndex()
-*     AddrComputeBaseSwizzle()
-*     AddrUseTileIndex()
-*     AddrUseCombinedSwizzle()
-*
-**/
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                      Callback functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-* @brief channel setting structure
-****************************************************************************************************
-*/
-typedef union _ADDR_CHANNEL_SETTING
-{
-    struct
-    {
-        UINT_8 valid   : 1;    ///< Indicate whehter this channel setting is valid
-        UINT_8 channel : 2;    ///< 0 for x channel, 1 for y channel, 2 for z channel
-        UINT_8 index   : 5;    ///< Channel index
-    };
-    UINT_8 value;              ///< Value
-} ADDR_CHANNEL_SETTING;
-
-/**
-****************************************************************************************************
-* @brief address equation key structure
-****************************************************************************************************
-*/
-typedef union _ADDR_EQUATION_KEY
-{
-    struct
-    {
-        UINT_32 log2ElementBytes : 3; ///< Log2 of Bytes per pixel
-        UINT_32 tileMode         : 5; ///< Tile mode
-        UINT_32 microTileType    : 3; ///< Micro tile type
-        UINT_32 pipeConfig       : 5; ///< pipe config
-        UINT_32 numBanksLog2     : 3; ///< Number of banks log2
-        UINT_32 bankWidth        : 4; ///< Bank width
-        UINT_32 bankHeight       : 4; ///< Bank height
-        UINT_32 macroAspectRatio : 3; ///< Macro tile aspect ratio
-        UINT_32 prt              : 1; ///< SI only, indicate whether this equation is for prt
-        UINT_32 reserved         : 1; ///< Reserved bit
-    } fields;
-    UINT_32 value;
-} ADDR_EQUATION_KEY;
-
-/**
-****************************************************************************************************
-* @brief address equation structure
-****************************************************************************************************
-*/
-#define ADDR_MAX_EQUATION_BIT 20u
-
-// Invalid equation index
-#define ADDR_INVALID_EQUATION_INDEX 0xFFFFFFFF
-
-typedef struct _ADDR_EQUATION
-{
-    ADDR_CHANNEL_SETTING addr[ADDR_MAX_EQUATION_BIT];  ///< addr setting
-                                                       ///< each bit is result of addr ^ xor ^ xor2
-    ADDR_CHANNEL_SETTING xor1[ADDR_MAX_EQUATION_BIT];  ///< xor setting
-    ADDR_CHANNEL_SETTING xor2[ADDR_MAX_EQUATION_BIT];  ///< xor2 setting
-    UINT_32              numBits;                      ///< The number of bits in equation
-    BOOL_32              stackedDepthSlices;           ///< TRUE if depth slices are treated as being
-                                                       ///< stacked vertically prior to swizzling
-} ADDR_EQUATION;
-
-
-/**
-****************************************************************************************************
-* @brief Alloc system memory flags.
-* @note These flags are reserved for future use and if flags are added will minimize the impact
-*       of the client.
-****************************************************************************************************
-*/
-typedef union _ADDR_ALLOCSYSMEM_FLAGS
-{
-    struct
-    {
-        UINT_32 reserved    : 32;  ///< Reserved for future use.
-    } fields;
-    UINT_32 value;
-
-} ADDR_ALLOCSYSMEM_FLAGS;
-
-/**
-****************************************************************************************************
-* @brief Alloc system memory input structure
-****************************************************************************************************
-*/
-typedef struct _ADDR_ALLOCSYSMEM_INPUT
-{
-    UINT_32                 size;           ///< Size of this structure in bytes
-
-    ADDR_ALLOCSYSMEM_FLAGS  flags;          ///< System memory flags.
-    UINT_32                 sizeInBytes;    ///< System memory allocation size in bytes.
-    ADDR_CLIENT_HANDLE      hClient;        ///< Client handle
-} ADDR_ALLOCSYSMEM_INPUT;
-
-/**
-****************************************************************************************************
-* ADDR_ALLOCSYSMEM
-*   @brief
-*       Allocate system memory callback function. Returns valid pointer on success.
-****************************************************************************************************
-*/
-typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
-    const ADDR_ALLOCSYSMEM_INPUT* pInput);
-
-/**
-****************************************************************************************************
-* @brief Free system memory input structure
-****************************************************************************************************
-*/
-typedef struct _ADDR_FREESYSMEM_INPUT
-{
-    UINT_32                 size;           ///< Size of this structure in bytes
-
-    VOID*                   pVirtAddr;      ///< Virtual address
-    ADDR_CLIENT_HANDLE      hClient;        ///< Client handle
-} ADDR_FREESYSMEM_INPUT;
-
-/**
-****************************************************************************************************
-* ADDR_FREESYSMEM
-*   @brief
-*       Free system memory callback function.
-*       Returns ADDR_OK on success.
-****************************************************************************************************
-*/
-typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
-    const ADDR_FREESYSMEM_INPUT* pInput);
-
-/**
-****************************************************************************************************
-* @brief Print debug message input structure
-****************************************************************************************************
-*/
-typedef struct _ADDR_DEBUGPRINT_INPUT
-{
-    UINT_32             size;           ///< Size of this structure in bytes
-
-    CHAR*               pDebugString;   ///< Debug print string
-    va_list             ap;             ///< Variable argument list
-    ADDR_CLIENT_HANDLE  hClient;        ///< Client handle
-} ADDR_DEBUGPRINT_INPUT;
-
-/**
-****************************************************************************************************
-* ADDR_DEBUGPRINT
-*   @brief
-*       Print debug message callback function.
-*       Returns ADDR_OK on success.
-****************************************************************************************************
-*/
-typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
-    const ADDR_DEBUGPRINT_INPUT* pInput);
-
-/**
-****************************************************************************************************
-* ADDR_CALLBACKS
-*
-*   @brief
-*       Address Library needs client to provide system memory alloc/free routines.
-****************************************************************************************************
-*/
-typedef struct _ADDR_CALLBACKS
-{
-    ADDR_ALLOCSYSMEM allocSysMem;   ///< Routine to allocate system memory
-    ADDR_FREESYSMEM  freeSysMem;    ///< Routine to free system memory
-    ADDR_DEBUGPRINT  debugPrint;    ///< Routine to print debug message
-} ADDR_CALLBACKS;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                               Create/Destroy functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-* ADDR_CREATE_FLAGS
-*
-*   @brief
-*       This structure is used to pass some setup in creation of AddrLib
-*   @note
-****************************************************************************************************
-*/
-typedef union _ADDR_CREATE_FLAGS
-{
-    struct
-    {
-        UINT_32 noCubeMipSlicesPad     : 1;    ///< Turn cubemap faces padding off
-        UINT_32 fillSizeFields         : 1;    ///< If clients fill size fields in all input and
-                                               ///  output structure
-        UINT_32 useTileIndex           : 1;    ///< Make tileIndex field in input valid
-        UINT_32 useCombinedSwizzle     : 1;    ///< Use combined tile swizzle
-        UINT_32 checkLast2DLevel       : 1;    ///< Check the last 2D mip sub level
-        UINT_32 useHtileSliceAlign     : 1;    ///< Do htile single slice alignment
-        UINT_32 allowLargeThickTile    : 1;    ///< Allow 64*thickness*bytesPerPixel > rowSize
-        UINT_32 reserved               : 25;   ///< Reserved bits for future use
-    };
-
-    UINT_32 value;
-} ADDR_CREATE_FLAGS;
-
-/**
-****************************************************************************************************
-*   ADDR_REGISTER_VALUE
-*
-*   @brief
-*       Data from registers to setup AddrLib global data, used in AddrCreate
-****************************************************************************************************
-*/
-typedef struct _ADDR_REGISTER_VALUE
-{
-    UINT_32  gbAddrConfig;       ///< For R8xx, use GB_ADDR_CONFIG register value.
-                                 ///  For R6xx/R7xx, use GB_TILING_CONFIG.
-                                 ///  But they can be treated as the same.
-                                 ///  if this value is 0, use chip to set default value
-    UINT_32  backendDisables;    ///< 1 bit per backend, starting with LSB. 1=disabled,0=enabled.
-                                 ///  Register value of CC_RB_BACKEND_DISABLE.BACKEND_DISABLE
-
-                                 ///  R800 registers-----------------------------------------------
-    UINT_32  noOfBanks;          ///< Number of h/w ram banks - For r800: MC_ARB_RAMCFG.NOOFBANK
-                                 ///  No enums for this value in h/w header files
-                                 ///  0: 4
-                                 ///  1: 8
-                                 ///  2: 16
-    UINT_32  noOfRanks;          ///  MC_ARB_RAMCFG.NOOFRANK
-                                 ///  0: 1
-                                 ///  1: 2
-                                 ///  SI (R1000) registers-----------------------------------------
-    const UINT_32* pTileConfig;  ///< Global tile setting tables
-    UINT_32  noOfEntries;        ///< Number of entries in pTileConfig
-
-                                 ///< CI registers-------------------------------------------------
-    const UINT_32* pMacroTileConfig;    ///< Global macro tile mode table
-    UINT_32  noOfMacroEntries;   ///< Number of entries in pMacroTileConfig
-
-                                 ///< GFX9 HW parameters
-    UINT_32  blockVarSizeLog2;   ///< SW_VAR_* block size
-} ADDR_REGISTER_VALUE;
-
-/**
-****************************************************************************************************
-* ADDR_CREATE_INPUT
-*
-*   @brief
-*       Parameters use to create an AddrLib Object. Caller must provide all fields.
-*
-****************************************************************************************************
-*/
-typedef struct _ADDR_CREATE_INPUT
-{
-    UINT_32             size;                ///< Size of this structure in bytes
-
-    UINT_32             chipEngine;          ///< Chip Engine
-    UINT_32             chipFamily;          ///< Chip Family
-    UINT_32             chipRevision;        ///< Chip Revision
-    ADDR_CALLBACKS      callbacks;           ///< Callbacks for sysmem alloc/free/print
-    ADDR_CREATE_FLAGS   createFlags;         ///< Flags to setup AddrLib
-    ADDR_REGISTER_VALUE regValue;            ///< Data from registers to setup AddrLib global data
-    ADDR_CLIENT_HANDLE  hClient;             ///< Client handle
-    UINT_32             minPitchAlignPixels; ///< Minimum pitch alignment in pixels
-} ADDR_CREATE_INPUT;
-
-/**
-****************************************************************************************************
-* ADDR_CREATEINFO_OUTPUT
-*
-*   @brief
-*       Return AddrLib handle to client driver
-*
-****************************************************************************************************
-*/
-typedef struct _ADDR_CREATE_OUTPUT
-{
-    UINT_32              size;            ///< Size of this structure in bytes
-
-    ADDR_HANDLE          hLib;            ///< Address lib handle
-
-    UINT_32              numEquations;    ///< Number of equations in the table
-    const ADDR_EQUATION* pEquationTable;  ///< Pointer to the equation table
-} ADDR_CREATE_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrCreate
-*
-*   @brief
-*       Create AddrLib object, must be called before any interface calls
-*
-*   @return
-*       ADDR_OK if successful
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrCreate(
-    const ADDR_CREATE_INPUT*    pAddrCreateIn,
-    ADDR_CREATE_OUTPUT*         pAddrCreateOut);
-
-
-
-/**
-****************************************************************************************************
-*   AddrDestroy
-*
-*   @brief
-*       Destroy AddrLib object, must be called to free internally allocated resources.
-*
-*   @return
-*      ADDR_OK if successful
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrDestroy(
-    ADDR_HANDLE hLib);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                    Surface functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-* @brief
-*       Bank/tiling parameters. On function input, these can be set as desired or
-*       left 0 for AddrLib to calculate/default. On function output, these are the actual
-*       parameters used.
-* @note
-*       Valid bankWidth/bankHeight value:
-*       1,2,4,8. They are factors instead of pixels or bytes.
-*
-*       The bank number remains constant across each row of the
-*       macro tile as each pipe is selected, so the number of
-*       tiles in the x direction with the same bank number will
-*       be bank_width * num_pipes.
-****************************************************************************************************
-*/
-typedef struct _ADDR_TILEINFO
-{
-    ///  Any of these parameters can be set to 0 to use the HW default.
-    UINT_32     banks;              ///< Number of banks, numerical value
-    UINT_32     bankWidth;          ///< Number of tiles in the X direction in the same bank
-    UINT_32     bankHeight;         ///< Number of tiles in the Y direction in the same bank
-    UINT_32     macroAspectRatio;   ///< Macro tile aspect ratio. 1-1:1, 2-4:1, 4-16:1, 8-64:1
-    UINT_32     tileSplitBytes;     ///< Tile split size, in bytes
-    AddrPipeCfg pipeConfig;         ///< Pipe Config = HW enum + 1
-} ADDR_TILEINFO;
-
-// Create a define to avoid client change. The removal of R800 is because we plan to implement SI
-// within 800 HWL - An AddrPipeCfg is added in above data structure
-typedef ADDR_TILEINFO ADDR_R800_TILEINFO;
-
-/**
-****************************************************************************************************
-* @brief
-*       Information needed by quad buffer stereo support
-****************************************************************************************************
-*/
-typedef struct _ADDR_QBSTEREOINFO
-{
-    UINT_32         eyeHeight;          ///< Height (in pixel rows) to right eye
-    UINT_32         rightOffset;        ///< Offset (in bytes) to right eye
-    UINT_32         rightSwizzle;       ///< TileSwizzle for right eyes
-} ADDR_QBSTEREOINFO;
-
-/**
-****************************************************************************************************
-*   ADDR_SURFACE_FLAGS
-*
-*   @brief
-*       Surface flags
-****************************************************************************************************
-*/
-typedef union _ADDR_SURFACE_FLAGS
-{
-    struct
-    {
-        UINT_32 color                : 1; ///< Flag indicates this is a color buffer
-        UINT_32 depth                : 1; ///< Flag indicates this is a depth/stencil buffer
-        UINT_32 stencil              : 1; ///< Flag indicates this is a stencil buffer
-        UINT_32 texture              : 1; ///< Flag indicates this is a texture
-        UINT_32 cube                 : 1; ///< Flag indicates this is a cubemap
-        UINT_32 volume               : 1; ///< Flag indicates this is a volume texture
-        UINT_32 fmask                : 1; ///< Flag indicates this is an fmask
-        UINT_32 cubeAsArray          : 1; ///< Flag indicates if treat cubemap as arrays
-        UINT_32 compressZ            : 1; ///< Flag indicates z buffer is compressed
-        UINT_32 overlay              : 1; ///< Flag indicates this is an overlay surface
-        UINT_32 noStencil            : 1; ///< Flag indicates this depth has no separate stencil
-        UINT_32 display              : 1; ///< Flag indicates this should match display controller req.
-        UINT_32 opt4Space            : 1; ///< Flag indicates this surface should be optimized for space
-                                          ///  i.e. save some memory but may lose performance
-        UINT_32 prt                  : 1; ///< Flag for partially resident texture
-        UINT_32 qbStereo             : 1; ///< Quad buffer stereo surface
-        UINT_32 pow2Pad              : 1; ///< SI: Pad to pow2, must set for mipmap (include level0)
-        UINT_32 interleaved          : 1; ///< Special flag for interleaved YUV surface padding
-        UINT_32 tcCompatible         : 1; ///< Flag indicates surface needs to be shader readable
-        UINT_32 dispTileType         : 1; ///< NI: force display Tiling for 128 bit shared resoruce
-        UINT_32 dccCompatible        : 1; ///< VI: whether to make MSAA surface support dcc fast clear
-        UINT_32 dccPipeWorkaround    : 1; ///< VI: whether to workaround the HW limit that
-                                          ///  dcc can't be enabled if pipe config of tile mode
-                                          ///  is different from that of ASIC, this flag
-                                          ///  is address lib internal flag, client should ignore it
-        UINT_32 czDispCompatible     : 1; ///< SI+: CZ family has a HW bug needs special alignment.
-                                          ///  This flag indicates we need to follow the
-                                          ///  alignment with CZ families or other ASICs under
-                                          ///  PX configuration + CZ.
-        UINT_32 nonSplit             : 1; ///< CI: depth texture should not be split
-        UINT_32 disableLinearOpt     : 1; ///< Disable tile mode optimization to linear
-        UINT_32 needEquation         : 1; ///< Make the surface tile setting equation compatible.
-                                          ///  This flag indicates we need to override tile
-                                          ///  mode to PRT_* tile mode to disable slice rotation,
-                                          ///  which is needed by swizzle pattern equation.
-        UINT_32 skipIndicesOutput    : 1; ///< Skipping indices in output.
-        UINT_32 rotateDisplay        : 1; ///< Rotate micro tile type
-        UINT_32 minimizeAlignment    : 1; ///< Minimize alignment
-        UINT_32 preferEquation       : 1; ///< Return equation index without adjusting tile mode
-        UINT_32 matchStencilTileCfg  : 1; ///< Select tile index of stencil as well as depth surface
-                                          ///  to make sure they share same tile config parameters
-        UINT_32 disallowLargeThickDegrade   : 1;    ///< Disallow large thick tile degrade
-        UINT_32 reserved             : 1; ///< Reserved bits
-    };
-
-    UINT_32 value;
-} ADDR_SURFACE_FLAGS;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SURFACE_INFO_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeSurfaceInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-
-    AddrTileMode        tileMode;           ///< Tile mode
-    AddrFormat          format;             ///< If format is set to valid one, bpp/width/height
-                                            ///  might be overwritten
-    UINT_32             bpp;                ///< Bits per pixel
-    UINT_32             numSamples;         ///< Number of samples
-    UINT_32             width;              ///< Width, in pixels
-    UINT_32             height;             ///< Height, in pixels
-    UINT_32             numSlices;          ///< Number of surface slices or depth
-    UINT_32             slice;              ///< Slice index
-    UINT_32             mipLevel;           ///< Current mipmap level
-    UINT_32             numMipLevels;       ///< Number of mips in mip chain
-    ADDR_SURFACE_FLAGS  flags;              ///< Surface type flags
-    UINT_32             numFrags;           ///< Number of fragments, leave it zero or the same as
-                                            ///  number of samples for normal AA; Set it to the
-                                            ///  number of fragments for EQAA
-    /// r800 and later HWL parameters
-    // Needed by 2D tiling, for linear and 1D tiling, just keep them 0's
-    ADDR_TILEINFO*      pTileInfo;          ///< 2D tile parameters. Set to 0 to default/calculate
-    AddrTileType        tileType;           ///< Micro tiling type, not needed when tileIndex != -1
-    INT_32              tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
-                                            ///  while the global useTileIndex is set to 1
-    UINT_32             basePitch;          ///< Base level pitch in pixels, 0 means ignored, is a
-                                            ///  must for mip levels from SI+.
-                                            ///  Don't use pitch in blocks for compressed formats!
-    UINT_32             maxBaseAlign;       ///< Max base alignment request from client
-    UINT_32             pitchAlign;         ///< Pitch alignment request from client
-    UINT_32             heightAlign;        ///< Height alignment request from client
-} ADDR_COMPUTE_SURFACE_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SURFACE_INFO_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeSurfInfo
-*   @note
-        Element: AddrLib unit for computing. e.g. BCn: 4x4 blocks; R32B32B32: 32bit with 3x pitch
-        Pixel: Original pixel
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SURFACE_INFO_OUTPUT
-{
-    UINT_32         size;           ///< Size of this structure in bytes
-
-    UINT_32         pitch;          ///< Pitch in elements (in blocks for compressed formats)
-    UINT_32         height;         ///< Height in elements (in blocks for compressed formats)
-    UINT_32         depth;          ///< Number of slice/depth
-    UINT_64         surfSize;       ///< Surface size in bytes
-    AddrTileMode    tileMode;       ///< Actual tile mode. May differ from that in input
-    UINT_32         baseAlign;      ///< Base address alignment
-    UINT_32         pitchAlign;     ///< Pitch alignment, in elements
-    UINT_32         heightAlign;    ///< Height alignment, in elements
-    UINT_32         depthAlign;     ///< Depth alignment, aligned to thickness, for 3d texture
-    UINT_32         bpp;            ///< Bits per elements (e.g. blocks for BCn, 1/3 for 96bit)
-    UINT_32         pixelPitch;     ///< Pitch in original pixels
-    UINT_32         pixelHeight;    ///< Height in original pixels
-    UINT_32         pixelBits;      ///< Original bits per pixel, passed from input
-    UINT_64         sliceSize;      ///< Size of slice specified by input's slice
-                                    ///  The result is controlled by surface flags & createFlags
-                                    ///  By default this value equals to surfSize for volume
-    UINT_32         pitchTileMax;   ///< PITCH_TILE_MAX value for h/w register
-    UINT_32         heightTileMax;  ///< HEIGHT_TILE_MAX value for h/w register
-    UINT_32         sliceTileMax;   ///< SLICE_TILE_MAX value for h/w register
-
-    UINT_32         numSamples;     ///< Pass the effective numSamples processed in this call
-
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*  pTileInfo;      ///< Tile parameters used. Filled in if 0 on input
-    AddrTileType    tileType;       ///< Micro tiling type, only valid when tileIndex != -1
-    INT_32          tileIndex;      ///< Tile index, MAY be "downgraded"
-
-    INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
-    /// Output flags
-    struct
-    {
-        /// Special information to work around SI mipmap swizzle bug UBTS #317508
-        UINT_32     last2DLevel  : 1;  ///< TRUE if this is the last 2D(3D) tiled
-                                       ///< Only meaningful when create flag checkLast2DLevel is set
-        UINT_32     tcCompatible : 1;  ///< If the surface can be shader compatible
-        UINT_32     dccUnsupport : 1;  ///< If the surface can support DCC compressed rendering
-        UINT_32     prtTileIndex : 1;  ///< SI only, indicate the returned tile index is for PRT
-                                       ///< If address lib return true for mip 0, client should set prt flag
-                                       ///< for child mips in subsequent compute surface info calls
-        UINT_32     reserved     :28;  ///< Reserved bits
-    };
-
-    UINT_32         equationIndex;     ///< Equation index in the equation table;
-
-    UINT_32         blockWidth;        ///< Width in element inside one block(1D->Micro, 2D->Macro)
-    UINT_32         blockHeight;       ///< Height in element inside one block(1D->Micro, 2D->Macro)
-    UINT_32         blockSlices;       ///< Slice number inside one block(1D->Micro, 2D->Macro)
-
-    /// Stereo info
-    ADDR_QBSTEREOINFO*  pStereoInfo;///< Stereo information, needed when .qbStereo flag is TRUE
-
-    INT_32          stencilTileIdx; ///< stencil tile index output when matchStencilTileCfg was set
-} ADDR_COMPUTE_SURFACE_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeSurfaceInfo
-*
-*   @brief
-*       Compute surface width/height/depth/alignments and suitable tiling mode
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
-    ADDR_HANDLE                             hLib,
-    const ADDR_COMPUTE_SURFACE_INFO_INPUT*  pIn,
-    ADDR_COMPUTE_SURFACE_INFO_OUTPUT*       pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeSurfaceAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    UINT_32         x;                  ///< X coordinate
-    UINT_32         y;                  ///< Y coordinate
-    UINT_32         slice;              ///< Slice index
-    UINT_32         sample;             ///< Sample index, use fragment index for EQAA
-
-    UINT_32         bpp;                ///< Bits per pixel
-    UINT_32         pitch;              ///< Surface pitch, in pixels
-    UINT_32         height;             ///< Surface height, in pixels
-    UINT_32         numSlices;          ///< Surface depth
-    UINT_32         numSamples;         ///< Number of samples
-
-    AddrTileMode    tileMode;           ///< Tile mode
-    BOOL_32         isDepth;            ///< TRUE if the surface uses depth sample ordering within
-                                        ///  micro tile. Textures can also choose depth sample order
-    UINT_32         tileBase;           ///< Base offset (in bits) inside micro tile which handles
-                                        ///  the case that components are stored separately
-    UINT_32         compBits;           ///< The component bits actually needed(for planar surface)
-
-    UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
-                                        ///  number of samples for normal AA; Set it to the
-                                        ///  number of fragments for EQAA
-    /// r800 and later HWL parameters
-    // Used for 1D tiling above
-    AddrTileType    tileType;           ///< See defintion of AddrTileType
-    struct
-    {
-        UINT_32     ignoreSE : 1;       ///< TRUE if shader engines are ignored. This is texture
-                                        ///  only flag. Only non-RT texture can set this to TRUE
-        UINT_32     reserved :31;       ///< Reserved for future use.
-    };
-    // 2D tiling needs following structure
-    ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
-    INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    union
-    {
-        struct
-        {
-            UINT_32  bankSwizzle;       ///< Bank swizzle
-            UINT_32  pipeSwizzle;       ///< Pipe swizzle
-        };
-        UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
-    };
-} ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeSurfaceAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_64 addr;           ///< Byte address
-    UINT_32 bitPosition;    ///< Bit position within surfaceAddr, 0-7.
-                            ///  For surface bpp < 8, e.g. FMT_1.
-    UINT_32 prtBlockIndex;  ///< Index of a PRT tile (64K block)
-} ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeSurfaceAddrFromCoord
-*
-*   @brief
-*       Compute surface address from a given coordinate.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
-    ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*      pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeSurfaceCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    UINT_64         addr;               ///< Address in bytes
-    UINT_32         bitPosition;        ///< Bit position in addr. 0-7. for surface bpp < 8,
-                                        ///  e.g. FMT_1;
-    UINT_32         bpp;                ///< Bits per pixel
-    UINT_32         pitch;              ///< Pitch, in pixels
-    UINT_32         height;             ///< Height in pixels
-    UINT_32         numSlices;          ///< Surface depth
-    UINT_32         numSamples;         ///< Number of samples
-
-    AddrTileMode    tileMode;           ///< Tile mode
-    BOOL_32         isDepth;            ///< Surface uses depth sample ordering within micro tile.
-                                        ///  Note: Textures can choose depth sample order as well.
-    UINT_32         tileBase;           ///< Base offset (in bits) inside micro tile which handles
-                                        ///  the case that components are stored separately
-    UINT_32         compBits;           ///< The component bits actually needed(for planar surface)
-
-    UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
-                                        ///  number of samples for normal AA; Set it to the
-                                        ///  number of fragments for EQAA
-    /// r800 and later HWL parameters
-    // Used for 1D tiling above
-    AddrTileType    tileType;           ///< See defintion of AddrTileType
-    struct
-    {
-        UINT_32     ignoreSE : 1;       ///< TRUE if shader engines are ignored. This is texture
-                                        ///  only flag. Only non-RT texture can set this to TRUE
-        UINT_32     reserved :31;       ///< Reserved for future use.
-    };
-    // 2D tiling needs following structure
-    ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
-    INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    union
-    {
-        struct
-        {
-            UINT_32  bankSwizzle;       ///< Bank swizzle
-            UINT_32  pipeSwizzle;       ///< Pipe swizzle
-        };
-        UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
-    };
-} ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeSurfaceCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
-{
-    UINT_32 size;   ///< Size of this structure in bytes
-
-    UINT_32 x;      ///< X coordinate
-    UINT_32 y;      ///< Y coordinate
-    UINT_32 slice;  ///< Index of slices
-    UINT_32 sample; ///< Index of samples, means fragment index for EQAA
-} ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeSurfaceCoordFromAddr
-*
-*   @brief
-*       Compute coordinate from a given surface address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
-    ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*      pOut);
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                   HTile functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR_HTILE_FLAGS
-*
-*   @brief
-*       HTILE flags
-****************************************************************************************************
-*/
-typedef union _ADDR_HTILE_FLAGS
-{
-    struct
-    {
-        UINT_32 tcCompatible          : 1;  ///< Flag indicates surface needs to be shader readable
-        UINT_32 skipTcCompatSizeAlign : 1;  ///< Flag indicates that addrLib will not align htile
-                                            ///  size to 256xBankxPipe when computing tc-compatible
-                                            ///  htile info.
-        UINT_32 reserved              : 30; ///< Reserved bits
-    };
-
-    UINT_32 value;
-} ADDR_HTILE_FLAGS;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_HTILE_INFO_INPUT
-*
-*   @brief
-*       Input structure of AddrComputeHtileInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_HTILE_INFO_INPUT
-{
-    UINT_32            size;            ///< Size of this structure in bytes
-
-    ADDR_HTILE_FLAGS   flags;           ///< HTILE flags
-    UINT_32            pitch;           ///< Surface pitch, in pixels
-    UINT_32            height;          ///< Surface height, in pixels
-    UINT_32            numSlices;       ///< Number of slices
-    BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
-    AddrHtileBlockSize blockWidth;      ///< 4 or 8. EG above only support 8
-    AddrHtileBlockSize blockHeight;     ///< 4 or 8. EG above only support 8
-    ADDR_TILEINFO*     pTileInfo;       ///< Tile info
-
-    INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
-                                        ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_HTILE_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_HTILE_INFO_OUTPUT
-*
-*   @brief
-*       Output structure of AddrComputeHtileInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_HTILE_INFO_OUTPUT
-{
-    UINT_32 size;               ///< Size of this structure in bytes
-
-    UINT_32 pitch;              ///< Pitch in pixels of depth buffer represented in this
-                                ///  HTile buffer. This might be larger than original depth
-                                ///  buffer pitch when called with an unaligned pitch.
-    UINT_32 height;             ///< Height in pixels, as above
-    UINT_64 htileBytes;         ///< Size of HTILE buffer, in bytes
-    UINT_32 baseAlign;          ///< Base alignment
-    UINT_32 bpp;                ///< Bits per pixel for HTILE is how many bits for an 8x8 block!
-    UINT_32 macroWidth;         ///< Macro width in pixels, actually squared cache shape
-    UINT_32 macroHeight;        ///< Macro height in pixels
-    UINT_64 sliceSize;          ///< Slice size, in bytes.
-    BOOL_32 sliceInterleaved;   ///< Flag to indicate if different slice's htile is interleaved
-                                ///  Compute engine clear can't be used if htile is interleaved
-    BOOL_32 nextMipLevelCompressible;   ///< Flag to indicate whether HTILE can be enabled in
-                                        ///  next mip level, it also indicates if memory set based
-                                        ///  fast clear can be used for current mip level.
-} ADDR_COMPUTE_HTILE_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeHtileInfo
-*
-*   @brief
-*       Compute Htile pitch, height, base alignment and size in bytes
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
-    ADDR_HANDLE                             hLib,
-    const ADDR_COMPUTE_HTILE_INFO_INPUT*    pIn,
-    ADDR_COMPUTE_HTILE_INFO_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeHtileAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
-{
-    UINT_32            size;            ///< Size of this structure in bytes
-
-    UINT_32            pitch;           ///< Pitch, in pixels
-    UINT_32            height;          ///< Height in pixels
-    UINT_32            x;               ///< X coordinate
-    UINT_32            y;               ///< Y coordinate
-    UINT_32            slice;           ///< Index of slice
-    UINT_32            numSlices;       ///< Number of slices
-    BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
-    ADDR_HTILE_FLAGS   flags;           ///< htile flags
-    AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
-    AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
-    ADDR_TILEINFO*     pTileInfo;       ///< Tile info
-
-    INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
-                                        ///< README: When tileIndex is not -1, this must be valid
-    UINT_32            bpp;             ///< depth/stencil buffer bit per pixel size
-    UINT_32            zStencilAddr;    ///< tcCompatible Z/Stencil surface address
-} ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeHtileAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_64 addr;           ///< Address in bytes
-    UINT_32 bitPosition;    ///< Bit position, 0 or 4. CMASK and HTILE shares some lib method.
-                            ///  So we keep bitPosition for HTILE as well
-} ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeHtileAddrFromCoord
-*
-*   @brief
-*       Compute Htile address according to coordinates (of depth buffer)
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*   pIn,
-    ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*        pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeHtileCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
-{
-    UINT_32            size;            ///< Size of this structure in bytes
-
-    UINT_64            addr;            ///< Address
-    UINT_32            bitPosition;     ///< Bit position 0 or 4. CMASK and HTILE share some methods
-                                        ///  so we keep bitPosition for HTILE as well
-    UINT_32            pitch;           ///< Pitch, in pixels
-    UINT_32            height;          ///< Height, in pixels
-    UINT_32            numSlices;       ///< Number of slices
-    BOOL_32            isLinear;        ///< Linear or tiled HTILE layout
-    AddrHtileBlockSize blockWidth;      ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
-    AddrHtileBlockSize blockHeight;     ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
-    ADDR_TILEINFO*     pTileInfo;       ///< Tile info
-
-    INT_32             tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    INT_32             macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
-                                        ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeHtileCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
-{
-    UINT_32 size;   ///< Size of this structure in bytes
-
-    UINT_32 x;      ///< X coordinate
-    UINT_32 y;      ///< Y coordinate
-    UINT_32 slice;  ///< Slice index
-} ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeHtileCoordFromAddr
-*
-*   @brief
-*       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
-*       Htile address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT*   pIn,
-    ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*        pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     C-mask functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR_CMASK_FLAGS
-*
-*   @brief
-*       CMASK flags
-****************************************************************************************************
-*/
-typedef union _ADDR_CMASK_FLAGS
-{
-    struct
-    {
-        UINT_32 tcCompatible  : 1; ///< Flag indicates surface needs to be shader readable
-        UINT_32 reserved      :31; ///< Reserved bits
-    };
-
-    UINT_32 value;
-} ADDR_CMASK_FLAGS;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_CMASK_INFO_INPUT
-*
-*   @brief
-*       Input structure of AddrComputeCmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
-{
-    UINT_32             size;            ///< Size of this structure in bytes
-
-    ADDR_CMASK_FLAGS    flags;           ///< CMASK flags
-    UINT_32             pitch;           ///< Pitch, in pixels, of color buffer
-    UINT_32             height;          ///< Height, in pixels, of color buffer
-    UINT_32             numSlices;       ///< Number of slices, of color buffer
-    BOOL_32             isLinear;        ///< Linear or tiled layout, Only SI can be linear
-    ADDR_TILEINFO*      pTileInfo;       ///< Tile info
-
-    INT_32              tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
-                                         ///  while the global useTileIndex is set to 1
-    INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
-                                         ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_CMASK_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_CMASK_INFO_OUTPUT
-*
-*   @brief
-*       Output structure of AddrComputeCmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_32 pitch;          ///< Pitch in pixels of color buffer which
-                            ///  this Cmask matches. The size might be larger than
-                            ///  original color buffer pitch when called with
-                            ///  an unaligned pitch.
-    UINT_32 height;         ///< Height in pixels, as above
-    UINT_64 cmaskBytes;     ///< Size in bytes of CMask buffer
-    UINT_32 baseAlign;      ///< Base alignment
-    UINT_32 blockMax;       ///< Cmask block size. Need this to set CB_COLORn_MASK register
-    UINT_32 macroWidth;     ///< Macro width in pixels, actually squared cache shape
-    UINT_32 macroHeight;    ///< Macro height in pixels
-    UINT_64 sliceSize;      ///< Slice size, in bytes.
-} ADDR_COMPUTE_CMASK_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeCmaskInfo
-*
-*   @brief
-*       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
-*       info
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
-    ADDR_HANDLE                             hLib,
-    const ADDR_COMPUTE_CMASK_INFO_INPUT*    pIn,
-    ADDR_COMPUTE_CMASK_INFO_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeCmaskAddrFromCoord
-*
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
-{
-    UINT_32          size;           ///< Size of this structure in bytes
-    UINT_32          x;              ///< X coordinate
-    UINT_32          y;              ///< Y coordinate
-    UINT_64          fmaskAddr;      ///< Fmask addr for tc compatible Cmask
-    UINT_32          slice;          ///< Slice index
-    UINT_32          pitch;          ///< Pitch in pixels, of color buffer
-    UINT_32          height;         ///< Height in pixels, of color buffer
-    UINT_32          numSlices;      ///< Number of slices
-    UINT_32          bpp;
-    BOOL_32          isLinear;       ///< Linear or tiled layout, Only SI can be linear
-    ADDR_CMASK_FLAGS flags;          ///< CMASK flags
-    ADDR_TILEINFO*   pTileInfo;      ///< Tile info
-
-    INT_32           tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
-                                     ///< while the global useTileIndex is set to 1
-    INT_32           macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
-                                     ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeCmaskAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_64 addr;           ///< CMASK address in bytes
-    UINT_32 bitPosition;    ///< Bit position within addr, 0-7. CMASK is 4 bpp,
-                            ///  so the address may be located in bit 0 (0) or 4 (4)
-} ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeCmaskAddrFromCoord
-*
-*   @brief
-*       Compute Cmask address according to coordinates (of MSAA color buffer)
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,
-    ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeCmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
-{
-    UINT_32        size;            ///< Size of this structure in bytes
-
-    UINT_64        addr;            ///< CMASK address in bytes
-    UINT_32        bitPosition;     ///< Bit position within addr, 0-7. CMASK is 4 bpp,
-                                    ///  so the address may be located in bit 0 (0) or 4 (4)
-    UINT_32        pitch;           ///< Pitch, in pixels
-    UINT_32        height;          ///< Height in pixels
-    UINT_32        numSlices;       ///< Number of slices
-    BOOL_32        isLinear;        ///< Linear or tiled layout, Only SI can be linear
-    ADDR_TILEINFO* pTileInfo;       ///< Tile info
-
-    INT_32         tileIndex;       ///< Tile index, MUST be -1 if you don't want to use it
-                                    ///  while the global useTileIndex is set to 1
-    INT_32         macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
-                                    ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeCmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
-{
-    UINT_32 size;   ///< Size of this structure in bytes
-
-    UINT_32 x;      ///< X coordinate
-    UINT_32 y;      ///< Y coordinate
-    UINT_32 slice;  ///< Slice index
-} ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeCmaskCoordFromAddr
-*
-*   @brief
-*       Compute coordinates within color buffer (1st pixel of a micro tile) according to
-*       Cmask address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT*   pIn,
-    ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*        pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     F-mask functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_FMASK_INFO_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeFmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    AddrTileMode    tileMode;           ///< Tile mode
-    UINT_32         pitch;              ///< Surface pitch, in pixels
-    UINT_32         height;             ///< Surface height, in pixels
-    UINT_32         numSlices;          ///< Number of slice/depth
-    UINT_32         numSamples;         ///< Number of samples
-    UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
-                                        ///  number of samples for normal AA; Set it to the
-                                        ///  number of fragments for EQAA
-    /// r800 and later HWL parameters
-    struct
-    {
-        UINT_32 resolved:   1;          ///< TRUE if the surface is for resolved fmask, only used
-                                        ///  by H/W clients. S/W should always set it to FALSE.
-        UINT_32 reserved:  31;          ///< Reserved for future use.
-    };
-    ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Clients must give valid data
-    INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-} ADDR_COMPUTE_FMASK_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_FMASK_INFO_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeFmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
-{
-    UINT_32         size;           ///< Size of this structure in bytes
-
-    UINT_32         pitch;          ///< Pitch of fmask in pixels
-    UINT_32         height;         ///< Height of fmask in pixels
-    UINT_32         numSlices;      ///< Slices of fmask
-    UINT_64         fmaskBytes;     ///< Size of fmask in bytes
-    UINT_32         baseAlign;      ///< Base address alignment
-    UINT_32         pitchAlign;     ///< Pitch alignment
-    UINT_32         heightAlign;    ///< Height alignment
-    UINT_32         bpp;            ///< Bits per pixel of FMASK is: number of bit planes
-    UINT_32         numSamples;     ///< Number of samples, used for dump, export this since input
-                                    ///  may be changed in 9xx and above
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*  pTileInfo;      ///< Tile parameters used. Fmask can have different
-                                    ///  bank_height from color buffer
-    INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
-                                    ///  while the global useTileIndex is set to 1
-    INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
-    UINT_64         sliceSize;      ///< Size of slice in bytes
-} ADDR_COMPUTE_FMASK_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeFmaskInfo
-*
-*   @brief
-*       Compute Fmask pitch/height/depth/alignments and size in bytes
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
-    ADDR_HANDLE                             hLib,
-    const ADDR_COMPUTE_FMASK_INFO_INPUT*    pIn,
-    ADDR_COMPUTE_FMASK_INFO_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeFmaskAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    UINT_32         x;                  ///< X coordinate
-    UINT_32         y;                  ///< Y coordinate
-    UINT_32         slice;              ///< Slice index
-    UINT_32         plane;              ///< Plane number
-    UINT_32         sample;             ///< Sample index (fragment index for EQAA)
-
-    UINT_32         pitch;              ///< Surface pitch, in pixels
-    UINT_32         height;             ///< Surface height, in pixels
-    UINT_32         numSamples;         ///< Number of samples
-    UINT_32         numFrags;           ///< Number of fragments, leave it zero or the same as
-                                        ///  number of samples for normal AA; Set it to the
-                                        ///  number of fragments for EQAA
-
-    AddrTileMode    tileMode;           ///< Tile mode
-    union
-    {
-        struct
-        {
-            UINT_32  bankSwizzle;       ///< Bank swizzle
-            UINT_32  pipeSwizzle;       ///< Pipe swizzle
-        };
-        UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
-    };
-
-    /// r800 and later HWL parameters
-    struct
-    {
-        UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by H/W clients
-        UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
-        UINT_32 reserved:  30;          ///< Reserved for future use.
-    };
-    ADDR_TILEINFO*  pTileInfo;          ///< 2D tiling parameters. Client must provide all data
-
-} ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeFmaskAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_64 addr;           ///< Fmask address
-    UINT_32 bitPosition;    ///< Bit position within fmaskAddr, 0-7.
-} ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeFmaskAddrFromCoord
-*
-*   @brief
-*       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*   pIn,
-    ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*        pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for AddrComputeFmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    UINT_64         addr;               ///< Address
-    UINT_32         bitPosition;        ///< Bit position within addr, 0-7.
-
-    UINT_32         pitch;              ///< Pitch, in pixels
-    UINT_32         height;             ///< Height in pixels
-    UINT_32         numSamples;         ///< Number of samples
-    UINT_32         numFrags;           ///< Number of fragments
-    AddrTileMode    tileMode;           ///< Tile mode
-    union
-    {
-        struct
-        {
-            UINT_32  bankSwizzle;       ///< Bank swizzle
-            UINT_32  pipeSwizzle;       ///< Pipe swizzle
-        };
-        UINT_32     tileSwizzle;        ///< Combined swizzle, if useCombinedSwizzle is TRUE
-    };
-
-    /// r800 and later HWL parameters
-    struct
-    {
-        UINT_32 resolved:   1;          ///< TRUE if this is a resolved fmask, used by HW components
-        UINT_32 ignoreSE:   1;          ///< TRUE if shader engines are ignored.
-        UINT_32 reserved:  30;          ///< Reserved for future use.
-    };
-    ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Client must provide all data
-
-} ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for AddrComputeFmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
-{
-    UINT_32 size;       ///< Size of this structure in bytes
-
-    UINT_32 x;          ///< X coordinate
-    UINT_32 y;          ///< Y coordinate
-    UINT_32 slice;      ///< Slice index
-    UINT_32 plane;      ///< Plane number
-    UINT_32 sample;     ///< Sample index (fragment index for EQAA)
-} ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeFmaskCoordFromAddr
-*
-*   @brief
-*       Compute FMASK coordinate from an given address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
-    ADDR_HANDLE                                     hLib,
-    const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT*   pIn,
-    ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*        pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                          Element/utility functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   AddrGetVersion
-*
-*   @brief
-*       Get AddrLib version number
-****************************************************************************************************
-*/
-UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib);
-
-/**
-****************************************************************************************************
-*   AddrUseTileIndex
-*
-*   @brief
-*       Return TRUE if tileIndex is enabled in this address library
-****************************************************************************************************
-*/
-BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib);
-
-/**
-****************************************************************************************************
-*   AddrUseCombinedSwizzle
-*
-*   @brief
-*       Return TRUE if combined swizzle is enabled in this address library
-****************************************************************************************************
-*/
-BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib);
-
-/**
-****************************************************************************************************
-*   ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
-*
-*   @brief
-*       Input structure of AddrExtractBankPipeSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
-{
-    UINT_32         size;           ///< Size of this structure in bytes
-
-    UINT_32         base256b;       ///< Base256b value
-
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
-
-    INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
-                                    ///  while the global useTileIndex is set to 1
-    INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
-                                    ///< README: When tileIndex is not -1, this must be valid
-} ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
-*
-*   @brief
-*       Output structure of AddrExtractBankPipeSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_32 bankSwizzle;    ///< Bank swizzle
-    UINT_32 pipeSwizzle;    ///< Pipe swizzle
-} ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrExtractBankPipeSwizzle
-*
-*   @brief
-*       Extract Bank and Pipe swizzle from base256b
-*   @return
-*       ADDR_OK if no error
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
-    ADDR_HANDLE                                 hLib,
-    const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT*  pIn,
-    ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
-*
-*   @brief
-*       Input structure of AddrCombineBankPipeSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
-{
-    UINT_32         size;           ///< Size of this structure in bytes
-
-    UINT_32         bankSwizzle;    ///< Bank swizzle
-    UINT_32         pipeSwizzle;    ///< Pipe swizzle
-    UINT_64         baseAddr;       ///< Base address (leave it zero for driver clients)
-
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*  pTileInfo;      ///< 2D tile parameters. Client must provide all data
-
-    INT_32          tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
-                                    ///  while the global useTileIndex is set to 1
-    INT_32          macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
-                                    ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
-*
-*   @brief
-*       Output structure of AddrCombineBankPipeSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_32 tileSwizzle;    ///< Combined swizzle
-} ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrCombineBankPipeSwizzle
-*
-*   @brief
-*       Combine Bank and Pipe swizzle
-*   @return
-*       ADDR_OK if no error
-*   @note
-*       baseAddr here is full MCAddress instead of base256b
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
-    ADDR_HANDLE                                 hLib,
-    const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT*  pIn,
-    ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT*       pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SLICESWIZZLE_INPUT
-*
-*   @brief
-*       Input structure of AddrComputeSliceSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    AddrTileMode    tileMode;           ///< Tile Mode
-    UINT_32         baseSwizzle;        ///< Base tile swizzle
-    UINT_32         slice;              ///< Slice index
-    UINT_64         baseAddr;           ///< Base address, driver should leave it 0 in most cases
-
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*  pTileInfo;          ///< 2D tile parameters. Actually banks needed here!
-
-    INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
-                                        ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_SLICESWIZZLE_INPUT;
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
-*
-*   @brief
-*       Output structure of AddrComputeSliceSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
-{
-    UINT_32  size;           ///< Size of this structure in bytes
-
-    UINT_32  tileSwizzle;    ///< Recalculated tileSwizzle value
-} ADDR_COMPUTE_SLICESWIZZLE_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeSliceSwizzle
-*
-*   @brief
-*       Extract Bank and Pipe swizzle from base256b
-*   @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);
-
-
-/**
-****************************************************************************************************
-*   AddrSwizzleGenOption
-*
-*   @brief
-*       Which swizzle generating options: legacy or linear
-****************************************************************************************************
-*/
-typedef enum _AddrSwizzleGenOption
-{
-    ADDR_SWIZZLE_GEN_DEFAULT    = 0,    ///< As is in client driver implemention for swizzle
-    ADDR_SWIZZLE_GEN_LINEAR     = 1,    ///< Using a linear increment of swizzle
-} AddrSwizzleGenOption;
-
-/**
-****************************************************************************************************
-*   AddrSwizzleOption
-*
-*   @brief
-*       Controls how swizzle is generated
-****************************************************************************************************
-*/
-typedef union _ADDR_SWIZZLE_OPTION
-{
-    struct
-    {
-        UINT_32 genOption       : 1;    ///< The way swizzle is generated, see AddrSwizzleGenOption
-        UINT_32 reduceBankBit   : 1;    ///< TRUE if we need reduce swizzle bits
-        UINT_32 reserved        :30;    ///< Reserved bits
-    };
-
-    UINT_32 value;
-
-} ADDR_SWIZZLE_OPTION;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_BASE_SWIZZLE_INPUT
-*
-*   @brief
-*       Input structure of AddrComputeBaseSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
-{
-    UINT_32             size;           ///< Size of this structure in bytes
-
-    ADDR_SWIZZLE_OPTION option;         ///< Swizzle option
-    UINT_32             surfIndex;      ///< Index of this surface type
-    AddrTileMode        tileMode;       ///< Tile Mode
-
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*      pTileInfo;      ///< 2D tile parameters. Actually banks needed here!
-
-    INT_32              tileIndex;      ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    INT_32              macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
-                                        ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_BASE_SWIZZLE_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
-*
-*   @brief
-*       Output structure of AddrComputeBaseSwizzle
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_32 tileSwizzle;    ///< Combined swizzle
-} ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT;
-
-/**
-****************************************************************************************************
-*   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);
-
-
-
-/**
-****************************************************************************************************
-*   ELEM_GETEXPORTNORM_INPUT
-*
-*   @brief
-*       Input structure for ElemGetExportNorm
-*
-****************************************************************************************************
-*/
-typedef struct _ELEM_GETEXPORTNORM_INPUT
-{
-    UINT_32             size;       ///< Size of this structure in bytes
-
-    AddrColorFormat     format;     ///< Color buffer format; Client should use ColorFormat
-    AddrSurfaceNumber   num;        ///< Surface number type; Client should use NumberType
-    AddrSurfaceSwap     swap;       ///< Surface swap byte swap; Client should use SurfaceSwap
-    UINT_32             numSamples; ///< Number of samples
-} ELEM_GETEXPORTNORM_INPUT;
-
-/**
-****************************************************************************************************
-*  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
-*   @note
-*       The implementation is only for r600.
-*       00 - EXPORT_FULL: PS exports are 4 pixels with 4 components with 32-bits-per-component. (two
-*       clocks per export)
-*       01 - EXPORT_NORM: PS exports are 4 pixels with 4 components with 16-bits-per-component. (one
-*       clock per export)
-*
-****************************************************************************************************
-*/
-BOOL_32 ADDR_API ElemGetExportNorm(
-    ADDR_HANDLE                     hLib,
-    const ELEM_GETEXPORTNORM_INPUT* pIn);
-
-
-
-/**
-****************************************************************************************************
-*   ELEM_FLT32TODEPTHPIXEL_INPUT
-*
-*   @brief
-*       Input structure for addrFlt32ToDepthPixel
-*
-****************************************************************************************************
-*/
-typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
-{
-    UINT_32         size;           ///< Size of this structure in bytes
-
-    AddrDepthFormat format;         ///< Depth buffer format
-    ADDR_FLT_32     comps[2];       ///< Component values (Z/stencil)
-} ELEM_FLT32TODEPTHPIXEL_INPUT;
-
-/**
-****************************************************************************************************
-*   ELEM_FLT32TODEPTHPIXEL_INPUT
-*
-*   @brief
-*       Output structure for ElemFlt32ToDepthPixel
-*
-****************************************************************************************************
-*/
-typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
-{
-    UINT_32 size;           ///< Size of this structure in bytes
-
-    UINT_8* pPixel;         ///< Real depth value. Same data type as depth buffer.
-                            ///  Client must provide enough storage for this type.
-    UINT_32 depthBase;      ///< Tile base in bits for depth bits
-    UINT_32 stencilBase;    ///< Tile base in bits for stencil bits
-    UINT_32 depthBits;      ///< Bits for depth
-    UINT_32 stencilBits;    ///< Bits for stencil
-} ELEM_FLT32TODEPTHPIXEL_OUTPUT;
-
-/**
-****************************************************************************************************
-*   ElemFlt32ToDepthPixel
-*
-*   @brief
-*       Convert a FLT_32 value to a depth/stencil pixel value
-*
-*   @return
-*       Return code
-*
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
-    ADDR_HANDLE                         hLib,
-    const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
-    ELEM_FLT32TODEPTHPIXEL_OUTPUT*      pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ELEM_FLT32TOCOLORPIXEL_INPUT
-*
-*   @brief
-*       Input structure for addrFlt32ToColorPixel
-*
-****************************************************************************************************
-*/
-typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
-{
-    UINT_32            size;           ///< Size of this structure in bytes
-
-    AddrColorFormat    format;         ///< Color buffer format
-    AddrSurfaceNumber  surfNum;        ///< Surface number
-    AddrSurfaceSwap    surfSwap;       ///< Surface swap
-    ADDR_FLT_32        comps[4];       ///< Component values (r/g/b/a)
-} ELEM_FLT32TOCOLORPIXEL_INPUT;
-
-/**
-****************************************************************************************************
-*   ELEM_FLT32TOCOLORPIXEL_INPUT
-*
-*   @brief
-*       Output structure for ElemFlt32ToColorPixel
-*
-****************************************************************************************************
-*/
-typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
-{
-    UINT_32 size;       ///< Size of this structure in bytes
-
-    UINT_8* pPixel;     ///< Real color value. Same data type as color buffer.
-                        ///  Client must provide enough storage for this type.
-} ELEM_FLT32TOCOLORPIXEL_OUTPUT;
-
-/**
-****************************************************************************************************
-*   ElemFlt32ToColorPixel
-*
-*   @brief
-*       Convert a FLT_32 value to a red/green/blue/alpha pixel value
-*
-*   @return
-*       Return code
-*
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
-    ADDR_HANDLE                         hLib,
-    const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
-    ELEM_FLT32TOCOLORPIXEL_OUTPUT*      pOut);
-
-
-/**
-****************************************************************************************************
-*   ADDR_CONVERT_TILEINFOTOHW_INPUT
-*
-*   @brief
-*       Input structure for AddrConvertTileInfoToHW
-*   @note
-*       When reverse is TRUE, indices are igonred
-****************************************************************************************************
-*/
-typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-    BOOL_32         reverse;            ///< Convert control flag.
-                                        ///  FALSE: convert from real value to HW value;
-                                        ///  TRUE: convert from HW value to real value.
-
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*  pTileInfo;          ///< Tile parameters with real value
-
-    INT_32          tileIndex;          ///< Tile index, MUST be -1 if you don't want to use it
-                                        ///  while the global useTileIndex is set to 1
-    INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
-                                        ///< README: When tileIndex is not -1, this must be valid
-    UINT_32         bpp;                ///< Bits per pixel
-} ADDR_CONVERT_TILEINFOTOHW_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_CONVERT_TILEINFOTOHW_OUTPUT
-*
-*   @brief
-*       Output structure for AddrConvertTileInfoToHW
-****************************************************************************************************
-*/
-typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-
-    /// r800 and later HWL parameters
-    ADDR_TILEINFO*      pTileInfo;          ///< Tile parameters with hardware register value
-
-} ADDR_CONVERT_TILEINFOTOHW_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrConvertTileInfoToHW
-*
-*   @brief
-*       Convert tile info from real value to hardware register value
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
-    ADDR_HANDLE                             hLib,
-    const ADDR_CONVERT_TILEINFOTOHW_INPUT*  pIn,
-    ADDR_CONVERT_TILEINFOTOHW_OUTPUT*       pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_CONVERT_TILEINDEX_INPUT
-*
-*   @brief
-*       Input structure for AddrConvertTileIndex
-****************************************************************************************************
-*/
-typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    INT_32          tileIndex;          ///< Tile index
-    INT_32          macroModeIndex;     ///< Index in macro tile mode table if there is one (CI)
-    UINT_32         bpp;                ///< Bits per pixel
-    BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
-} ADDR_CONVERT_TILEINDEX_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_CONVERT_TILEINDEX_OUTPUT
-*
-*   @brief
-*       Output structure for AddrConvertTileIndex
-****************************************************************************************************
-*/
-typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
-{
-    UINT_32             size;           ///< Size of this structure in bytes
-
-    AddrTileMode        tileMode;       ///< Tile mode
-    AddrTileType        tileType;       ///< Tile type
-    ADDR_TILEINFO*      pTileInfo;      ///< Tile info
-
-} ADDR_CONVERT_TILEINDEX_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrConvertTileIndex
-*
-*   @brief
-*       Convert tile index to tile mode/type/info
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
-    ADDR_HANDLE                         hLib,
-    const ADDR_CONVERT_TILEINDEX_INPUT* pIn,
-    ADDR_CONVERT_TILEINDEX_OUTPUT*      pOut);
-
-/**
-****************************************************************************************************
-*   ADDR_GET_MACROMODEINDEX_INPUT
-*
-*   @brief
-*       Input structure for AddrGetMacroModeIndex
-****************************************************************************************************
-*/
-typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-    ADDR_SURFACE_FLAGS  flags;              ///< Surface flag
-    INT_32              tileIndex;          ///< Tile index
-    UINT_32             bpp;                ///< Bits per pixel
-    UINT_32             numFrags;           ///< Number of color fragments
-} ADDR_GET_MACROMODEINDEX_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_GET_MACROMODEINDEX_OUTPUT
-*
-*   @brief
-*       Output structure for AddrGetMacroModeIndex
-****************************************************************************************************
-*/
-typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
-{
-    UINT_32             size;            ///< Size of this structure in bytes
-    INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
-} ADDR_GET_MACROMODEINDEX_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrGetMacroModeIndex
-*
-*   @brief
-*       Get macro mode index based on input parameters
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
-    ADDR_HANDLE                          hLib,
-    const ADDR_GET_MACROMODEINDEX_INPUT* pIn,
-    ADDR_GET_MACROMODEINDEX_OUTPUT*      pOut);
-
-/**
-****************************************************************************************************
-*   ADDR_CONVERT_TILEINDEX1_INPUT
-*
-*   @brief
-*       Input structure for AddrConvertTileIndex1 (without macro mode index)
-****************************************************************************************************
-*/
-typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
-{
-    UINT_32         size;               ///< Size of this structure in bytes
-
-    INT_32          tileIndex;          ///< Tile index
-    UINT_32         bpp;                ///< Bits per pixel
-    UINT_32         numSamples;         ///< Number of samples
-    BOOL_32         tileInfoHw;         ///< Set to TRUE if client wants HW enum, otherwise actual
-} ADDR_CONVERT_TILEINDEX1_INPUT;
-
-/**
-****************************************************************************************************
-*   AddrConvertTileIndex1
-*
-*   @brief
-*       Convert tile index to tile mode/type/info
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
-    ADDR_HANDLE                             hLib,
-    const ADDR_CONVERT_TILEINDEX1_INPUT*    pIn,
-    ADDR_CONVERT_TILEINDEX_OUTPUT*          pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_GET_TILEINDEX_INPUT
-*
-*   @brief
-*       Input structure for AddrGetTileIndex
-****************************************************************************************************
-*/
-typedef struct _ADDR_GET_TILEINDEX_INPUT
-{
-    UINT_32         size;           ///< Size of this structure in bytes
-
-    AddrTileMode    tileMode;       ///< Tile mode
-    AddrTileType    tileType;       ///< Tile-type: disp/non-disp/...
-    ADDR_TILEINFO*  pTileInfo;      ///< Pointer to tile-info structure, can be NULL for linear/1D
-} ADDR_GET_TILEINDEX_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_GET_TILEINDEX_OUTPUT
-*
-*   @brief
-*       Output structure for AddrGetTileIndex
-****************************************************************************************************
-*/
-typedef struct _ADDR_GET_TILEINDEX_OUTPUT
-{
-    UINT_32         size;           ///< Size of this structure in bytes
-
-    INT_32          index;          ///< index in table
-} ADDR_GET_TILEINDEX_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrGetTileIndex
-*
-*   @brief
-*       Get the tiling mode index in table
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
-    ADDR_HANDLE                     hLib,
-    const ADDR_GET_TILEINDEX_INPUT* pIn,
-    ADDR_GET_TILEINDEX_OUTPUT*      pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_PRT_INFO_INPUT
-*
-*   @brief
-*       Input structure for AddrComputePrtInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_PRT_INFO_INPUT
-{
-    AddrFormat          format;        ///< Surface format
-    UINT_32             baseMipWidth;  ///< Base mipmap width
-    UINT_32             baseMipHeight; ///< Base mipmap height
-    UINT_32             baseMipDepth;  ///< Base mipmap depth
-    UINT_32             numFrags;      ///< Number of fragments,
-} ADDR_PRT_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_PRT_INFO_OUTPUT
-*
-*   @brief
-*       Input structure for AddrComputePrtInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_PRT_INFO_OUTPUT
-{
-    UINT_32             prtTileWidth;
-    UINT_32             prtTileHeight;
-} ADDR_PRT_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputePrtInfo
-*
-*   @brief
-*       Compute prt surface related information
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
-    ADDR_HANDLE                 hLib,
-    const ADDR_PRT_INFO_INPUT*  pIn,
-    ADDR_PRT_INFO_OUTPUT*       pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     DCC key functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   _ADDR_COMPUTE_DCCINFO_INPUT
-*
-*   @brief
-*       Input structure of AddrComputeDccInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
-{
-    UINT_32             size;            ///< Size of this structure in bytes
-    UINT_32             bpp;             ///< BitPP of color surface
-    UINT_32             numSamples;      ///< Sample number of color surface
-    UINT_64             colorSurfSize;   ///< Size of color surface to which dcc key is bound
-    AddrTileMode        tileMode;        ///< Tile mode of color surface
-    ADDR_TILEINFO       tileInfo;        ///< Tile info of color surface
-    UINT_32             tileSwizzle;     ///< Tile swizzle
-    INT_32              tileIndex;       ///< Tile index of color surface,
-                                         ///< MUST be -1 if you don't want to use it
-                                         ///< while the global useTileIndex is set to 1
-    INT_32              macroModeIndex;  ///< Index in macro tile mode table if there is one (CI)
-                                         ///< README: When tileIndex is not -1, this must be valid
-} ADDR_COMPUTE_DCCINFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR_COMPUTE_DCCINFO_OUTPUT
-*
-*   @brief
-*       Output structure of AddrComputeDccInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
-{
-    UINT_32 size;                 ///< Size of this structure in bytes
-    UINT_32 dccRamBaseAlign;      ///< Base alignment of dcc key
-    UINT_64 dccRamSize;           ///< Size of dcc key
-    UINT_64 dccFastClearSize;     ///< Size of dcc key portion that can be fast cleared
-    BOOL_32 subLvlCompressible;   ///< Whether sub resource is compressiable
-    BOOL_32 dccRamSizeAligned;    ///< Whether the dcc key size is aligned
-} ADDR_COMPUTE_DCCINFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrComputeDccInfo
-*
-*   @brief
-*       Compute DCC key size, base alignment
-*       info
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo(
-    ADDR_HANDLE                             hLib,
-    const ADDR_COMPUTE_DCCINFO_INPUT*       pIn,
-    ADDR_COMPUTE_DCCINFO_OUTPUT*            pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR_GET_MAX_ALINGMENTS_OUTPUT
-*
-*   @brief
-*       Output structure of AddrGetMaxAlignments
-****************************************************************************************************
-*/
-typedef struct _ADDR_GET_MAX_ALINGMENTS_OUTPUT
-{
-    UINT_32 size;                   ///< Size of this structure in bytes
-    UINT_32 baseAlign;              ///< Maximum base alignment in bytes
-} ADDR_GET_MAX_ALINGMENTS_OUTPUT;
-
-/**
-****************************************************************************************************
-*   AddrGetMaxAlignments
-*
-*   @brief
-*       Gets maximnum alignments
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
-    ADDR_HANDLE                     hLib,
-    ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut);
-
-/**
-****************************************************************************************************
-*   AddrGetMaxMetaAlignments
-*
-*   @brief
-*       Gets maximnum alignments for metadata
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API AddrGetMaxMetaAlignments(
-    ADDR_HANDLE                     hLib,
-    ADDR_GET_MAX_ALINGMENTS_OUTPUT* pOut);
-
-/**
-****************************************************************************************************
-*                                Address library interface version 2
-*                                    available from Gfx9 hardware
-****************************************************************************************************
-*     Addr2ComputeSurfaceInfo()
-*     Addr2ComputeSurfaceAddrFromCoord()
-*     Addr2ComputeSurfaceCoordFromAddr()
-
-*     Addr2ComputeHtileInfo()
-*     Addr2ComputeHtileAddrFromCoord()
-*     Addr2ComputeHtileCoordFromAddr()
-*
-*     Addr2ComputeCmaskInfo()
-*     Addr2ComputeCmaskAddrFromCoord()
-*     Addr2ComputeCmaskCoordFromAddr()
-*
-*     Addr2ComputeFmaskInfo()
-*     Addr2ComputeFmaskAddrFromCoord()
-*     Addr2ComputeFmaskCoordFromAddr()
-*
-*     Addr2ComputeDccInfo()
-*
-**/
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                    Surface functions for Gfx9
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR2_SURFACE_FLAGS
-*
-*   @brief
-*       Surface flags
-****************************************************************************************************
-*/
-typedef union _ADDR2_SURFACE_FLAGS
-{
-    struct
-    {
-        UINT_32 color             :  1; ///< This resource is a color buffer, can be used with RTV
-        UINT_32 depth             :  1; ///< Thie resource is a depth buffer, can be used with DSV
-        UINT_32 stencil           :  1; ///< Thie resource is a stencil buffer, can be used with DSV
-        UINT_32 fmask             :  1; ///< This is an fmask surface
-        UINT_32 overlay           :  1; ///< This is an overlay surface
-        UINT_32 display           :  1; ///< This resource is displable, can be used with DRV
-        UINT_32 prt               :  1; ///< This is a partially resident texture
-        UINT_32 qbStereo          :  1; ///< This is a quad buffer stereo surface
-        UINT_32 interleaved       :  1; ///< Special flag for interleaved YUV surface padding
-        UINT_32 texture           :  1; ///< This resource can be used with SRV
-        UINT_32 unordered         :  1; ///< This resource can be used with UAV
-        UINT_32 rotated           :  1; ///< This resource is rotated and displable
-        UINT_32 needEquation      :  1; ///< This resource needs equation to be generated if possible
-        UINT_32 opt4space         :  1; ///< This resource should be optimized for space
-        UINT_32 minimizeAlign     :  1; ///< This resource should use minimum alignment
-        UINT_32 noMetadata        :  1; ///< This resource has no metadata
-        UINT_32 metaRbUnaligned   :  1; ///< This resource has rb unaligned metadata
-        UINT_32 metaPipeUnaligned :  1; ///< This resource has pipe unaligned metadata
-        UINT_32 reserved          : 14; ///< Reserved bits
-    };
-
-    UINT_32 value;
-} ADDR2_SURFACE_FLAGS;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SURFACE_INFO_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeSurfaceInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SURFACE_INFO_INPUT
-{
-    UINT_32               size;              ///< Size of this structure in bytes
-
-    ADDR2_SURFACE_FLAGS   flags;             ///< Surface flags
-    AddrSwizzleMode       swizzleMode;       ///< Swizzle Mode for Gfx9
-    AddrResourceType      resourceType;      ///< Surface type
-    AddrFormat            format;            ///< Surface format
-    UINT_32               bpp;               ///< bits per pixel
-    UINT_32               width;             ///< Width (of mip0), in pixels
-    UINT_32               height;            ///< Height (of mip0), in pixels
-    UINT_32               numSlices;         ///< Number surface slice/depth (of mip0),
-    UINT_32               numMipLevels;      ///< Total mipmap levels.
-    UINT_32               numSamples;        ///< Number of samples
-    UINT_32               numFrags;          ///< Number of fragments, leave it zero or the same as
-                                             ///  number of samples for normal AA; Set it to the
-                                             ///  number of fragments for EQAA
-    UINT_32               pitchInElement;    ///< Pitch in elements (blocks for compressed formats)
-    UINT_32               sliceAlign;        ///< Required slice size in bytes
-} ADDR2_COMPUTE_SURFACE_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_MIP_INFO
-*
-*   @brief
-*       Structure that contains information for mip level
-*
-****************************************************************************************************
-*/
-typedef struct _ADDR2_MIP_INFO
-{
-    UINT_32             pitch;              ///< Pitch in elements
-    UINT_32             height;             ///< Padded height in elements
-    UINT_32             depth;              ///< Padded depth
-    UINT_32             pixelPitch;         ///< Pitch in pixels
-    UINT_32             pixelHeight;        ///< Padded height in pixels
-    UINT_32             equationIndex;      ///< Equation index in the equation table
-    UINT_64             offset;             ///< Offset in bytes from mip base, should only be used
-                                            ///< to setup vam surface descriptor, can't be used
-                                            ///< to setup swizzle pattern
-    UINT_64             macroBlockOffset;   ///< macro block offset in bytes from mip base
-    UINT_32             mipTailOffset;      ///< mip tail offset in bytes
-    UINT_32             mipTailCoordX;      ///< mip tail coord x
-    UINT_32             mipTailCoordY;      ///< mip tail coord y
-    UINT_32             mipTailCoordZ;      ///< mip tail coord z
-} ADDR2_MIP_INFO;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SURFACE_INFO_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeSurfInfo
-*   @note
-        Element: AddrLib unit for computing. e.g. BCn: 4x4 blocks; R32B32B32: 32bit with 3x pitch
-        Pixel: Original pixel
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SURFACE_INFO_OUTPUT
-{
-    UINT_32             size;                 ///< Size of this structure in bytes
-
-    UINT_32             pitch;                ///< Pitch in elements (blocks for compressed formats)
-    UINT_32             height;               ///< Padded height (of mip0) in elements
-    UINT_32             numSlices;            ///< Padded depth for 3d resource
-                                              ///< or padded number of slices for 2d array resource
-    UINT_32             mipChainPitch;        ///< Pitch (of total mip chain) in elements
-    UINT_32             mipChainHeight;       ///< Padded height (of total mip chain) in elements
-    UINT_32             mipChainSlice;        ///< Padded depth (of total mip chain)
-    UINT_64             sliceSize;            ///< Slice (total mip chain) size in bytes
-    UINT_64             surfSize;             ///< Surface (total mip chain) size in bytes
-    UINT_32             baseAlign;            ///< Base address alignment
-    UINT_32             bpp;                  ///< Bits per elements
-                                              ///  (e.g. blocks for BCn, 1/3 for 96bit)
-    UINT_32             pixelMipChainPitch;   ///< Mip chain pitch in original pixels
-    UINT_32             pixelMipChainHeight;  ///< Mip chain height in original pixels
-    UINT_32             pixelPitch;           ///< Pitch in original pixels
-    UINT_32             pixelHeight;          ///< Height in original pixels
-    UINT_32             pixelBits;            ///< Original bits per pixel, passed from input
-
-    UINT_32             blockWidth;           ///< Width in element inside one block
-    UINT_32             blockHeight;          ///< Height in element inside one block
-    UINT_32             blockSlices;          ///< Slice number inside one block
-                                              ///< Prt tile is one block, its width/height/slice
-                                              ///< equals to blcok width/height/slice
-
-    BOOL_32             epitchIsHeight;       ///< Whether to use height to program epitch register
-    /// Stereo info
-    ADDR_QBSTEREOINFO*  pStereoInfo;          ///< Stereo info, needed if qbStereo flag is TRUE
-    /// Mip info
-    ADDR2_MIP_INFO*     pMipInfo;             ///< Pointer to mip information array
-                                              ///  if it is not NULL, the array is assumed to
-                                              ///  contain numMipLevels entries
-
-    UINT_32             equationIndex;        ///< Equation index in the equation table of mip0
-    BOOL_32             mipChainInTail;       ///< If whole mipchain falls into mip tail block
-    UINT_32             firstMipIdInTail;     ///< The id of first mip in tail, if there is no mip
-                                              ///  in tail, it will be set to number of mip levels
-} ADDR2_COMPUTE_SURFACE_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSurfaceInfo
-*
-*   @brief
-*       Compute surface width/height/slices/alignments and suitable tiling mode
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceInfo(
-    ADDR_HANDLE                                hLib,
-    const ADDR2_COMPUTE_SURFACE_INFO_INPUT*    pIn,
-    ADDR2_COMPUTE_SURFACE_INFO_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeSurfaceAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
-{
-    UINT_32             size;            ///< Size of this structure in bytes
-
-    UINT_32             x;               ///< X coordinate
-    UINT_32             y;               ///< Y coordinate
-    UINT_32             slice;           ///< Slice index
-    UINT_32             sample;          ///< Sample index, use fragment index for EQAA
-    UINT_32             mipId;           ///< the mip ID in mip chain
-
-    AddrSwizzleMode     swizzleMode;     ///< Swizzle mode for Gfx9
-    ADDR2_SURFACE_FLAGS flags;           ///< Surface flags
-    AddrResourceType    resourceType;    ///< Surface type
-    UINT_32             bpp;             ///< Bits per pixel
-    UINT_32             unalignedWidth;  ///< Surface original width (of mip0)
-    UINT_32             unalignedHeight; ///< Surface original height (of mip0)
-    UINT_32             numSlices;       ///< Surface original slices (of mip0)
-    UINT_32             numMipLevels;    ///< Total mipmap levels
-    UINT_32             numSamples;      ///< Number of samples
-    UINT_32             numFrags;        ///< Number of fragments, leave it zero or the same as
-                                         ///  number of samples for normal AA; Set it to the
-                                         ///  number of fragments for EQAA
-
-    UINT_32             pipeBankXor;     ///< Combined swizzle used to do bank/pipe rotation
-    UINT_32             pitchInElement;  ///< Pitch in elements (blocks for compressed formats)
-} ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeSurfaceAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32    size;             ///< Size of this structure in bytes
-
-    UINT_64    addr;             ///< Byte address
-    UINT_32    bitPosition;      ///< Bit position within surfaceAddr, 0-7.
-                                 ///  For surface bpp < 8, e.g. FMT_1.
-    UINT_32    prtBlockIndex;    ///< Index of a PRT tile (64K block)
-} ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSurfaceAddrFromCoord
-*
-*   @brief
-*       Compute surface address from a given coordinate.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceAddrFromCoord(
-    ADDR_HANDLE                                         hLib,
-    const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT*    pIn,
-    ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeSurfaceCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT
-{
-    UINT_32             size;            ///< Size of this structure in bytes
-
-    UINT_64             addr;            ///< Address in bytes
-    UINT_32             bitPosition;     ///< Bit position in addr. 0-7. for surface bpp < 8,
-                                         ///  e.g. FMT_1;
-
-    AddrSwizzleMode     swizzleMode;     ///< Swizzle mode for Gfx9
-    ADDR2_SURFACE_FLAGS flags;           ///< Surface flags
-    AddrResourceType    resourceType;    ///< Surface type
-    UINT_32             bpp;             ///< Bits per pixel
-    UINT_32             unalignedWidth;  ///< Surface original width (of mip0)
-    UINT_32             unalignedHeight; ///< Surface original height (of mip0)
-    UINT_32             numSlices;       ///< Surface original slices (of mip0)
-    UINT_32             numMipLevels;    ///< Total mipmap levels.
-    UINT_32             numSamples;      ///< Number of samples
-    UINT_32             numFrags;        ///< Number of fragments, leave it zero or the same as
-                                         ///  number of samples for normal AA; Set it to the
-                                         ///  number of fragments for EQAA
-
-    UINT_32             pipeBankXor;     ///< Combined swizzle used to do bank/pipe rotation
-    UINT_32             pitchInElement;  ///< Pitch in elements (blocks for compressed formats)
-} ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeSurfaceCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
-{
-    UINT_32    size;       ///< Size of this structure in bytes
-
-    UINT_32    x;          ///< X coordinate
-    UINT_32    y;          ///< Y coordinate
-    UINT_32    slice;      ///< Index of slices
-    UINT_32    sample;     ///< Index of samples, means fragment index for EQAA
-    UINT_32    mipId;      ///< mipmap level id
-} ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSurfaceCoordFromAddr
-*
-*   @brief
-*       Compute coordinate from a given surface address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceCoordFromAddr(
-    ADDR_HANDLE                                         hLib,
-    const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT*    pIn,
-    ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT*         pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                   HTile functions for Gfx9
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR2_META_FLAGS
-*
-*   @brief
-*       Metadata flags
-****************************************************************************************************
-*/
-typedef union _ADDR2_META_FLAGS
-{
-    struct
-    {
-        UINT_32 pipeAligned :  1;    ///< if Metadata being pipe aligned
-        UINT_32 rbAligned   :  1;    ///< if Metadata being RB aligned
-        UINT_32 linear      :  1;    ///< if Metadata linear, GFX9 does not suppord this!
-        UINT_32 reserved    : 29;    ///< Reserved bits
-    };
-
-    UINT_32 value;
-} ADDR2_META_FLAGS;
-
-/**
-****************************************************************************************************
-*   ADDR2_META_MIP_INFO
-*
-*   @brief
-*       Structure to store per mip metadata information
-****************************************************************************************************
-*/
-typedef struct _ADDR2_META_MIP_INFO
-{
-    BOOL_32    inMiptail;
-    union
-    {
-        struct
-        {
-            UINT_32    startX;
-            UINT_32    startY;
-            UINT_32    startZ;
-            UINT_32    width;
-            UINT_32    height;
-            UINT_32    depth;
-        };
-
-        struct
-        {
-            UINT_32    offset;
-            UINT_32    sliceSize;
-        };
-    };
-} ADDR2_META_MIP_INFO;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_HTILE_INFO_INPUT
-*
-*   @brief
-*       Input structure of Addr2ComputeHtileInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_HTILE_INFO_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-
-    ADDR2_META_FLAGS    hTileFlags;         ///< HTILE flags
-    ADDR2_SURFACE_FLAGS depthFlags;         ///< Depth surface flags
-    AddrSwizzleMode     swizzleMode;        ///< Depth surface swizzle mode
-    UINT_32             unalignedWidth;     ///< Depth surface original width (of mip0)
-    UINT_32             unalignedHeight;    ///< Depth surface original height (of mip0)
-    UINT_32             numSlices;          ///< Number of slices of depth surface (of mip0)
-    UINT_32             numMipLevels;       ///< Total mipmap levels of color surface
-    UINT_32             firstMipIdInTail;
-} ADDR2_COMPUTE_HTILE_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_HTILE_INFO_OUTPUT
-*
-*   @brief
-*       Output structure of Addr2ComputeHtileInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_HTILE_INFO_OUTPUT
-{
-    UINT_32    size;                ///< Size of this structure in bytes
-
-    UINT_32    pitch;               ///< Pitch in pixels of depth buffer represented in this
-                                    ///  HTile buffer. This might be larger than original depth
-                                    ///  buffer pitch when called with an unaligned pitch.
-    UINT_32    height;              ///< Height in pixels, as above
-    UINT_32    baseAlign;           ///< Base alignment
-    UINT_32    sliceSize;           ///< Slice size, in bytes.
-    UINT_32    htileBytes;          ///< Size of HTILE buffer, in bytes
-    UINT_32    metaBlkWidth;        ///< Meta block width
-    UINT_32    metaBlkHeight;       ///< Meta block height
-    UINT_32    metaBlkNumPerSlice;  ///< Number of metablock within one slice
-
-    ADDR2_META_MIP_INFO* pMipInfo;  ///< HTILE mip information
-} ADDR2_COMPUTE_HTILE_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeHtileInfo
-*
-*   @brief
-*       Compute Htile pitch, height, base alignment and size in bytes
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileInfo(
-    ADDR_HANDLE                              hLib,
-    const ADDR2_COMPUTE_HTILE_INFO_INPUT*    pIn,
-    ADDR2_COMPUTE_HTILE_INFO_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeHtileAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
-{
-    UINT_32             size;                ///< Size of this structure in bytes
-
-    UINT_32             x;                   ///< X coordinate
-    UINT_32             y;                   ///< Y coordinate
-    UINT_32             slice;               ///< Index of slices
-    UINT_32             mipId;               ///< mipmap level id
-
-    ADDR2_META_FLAGS    hTileFlags;          ///< HTILE flags
-    ADDR2_SURFACE_FLAGS depthflags;          ///< Depth surface flags
-    AddrSwizzleMode     swizzleMode;         ///< Depth surface swizzle mode
-    UINT_32             bpp;                 ///< Depth surface bits per pixel
-    UINT_32             unalignedWidth;      ///< Depth surface original width (of mip0)
-    UINT_32             unalignedHeight;     ///< Depth surface original height (of mip0)
-    UINT_32             numSlices;           ///< Depth surface original depth (of mip0)
-    UINT_32             numMipLevels;        ///< Depth surface total mipmap levels
-    UINT_32             numSamples;          ///< Depth surface number of samples
-    UINT_32             pipeXor;             ///< Pipe xor setting
-} ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeHtileAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32    size;    ///< Size of this structure in bytes
-
-    UINT_64    addr;    ///< Address in bytes
-} ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeHtileAddrFromCoord
-*
-*   @brief
-*       Compute Htile address according to coordinates (of depth buffer)
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileAddrFromCoord(
-    ADDR_HANDLE                                       hLib,
-    const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT*    pIn,
-    ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeHtileCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT
-{
-    UINT_32             size;                ///< Size of this structure in bytes
-
-    UINT_64             addr;                ///< Address
-
-    ADDR2_META_FLAGS    hTileFlags;          ///< HTILE flags
-    ADDR2_SURFACE_FLAGS depthFlags;          ///< Depth surface flags
-    AddrSwizzleMode     swizzleMode;         ///< Depth surface swizzle mode
-    UINT_32             bpp;                 ///< Depth surface bits per pixel
-    UINT_32             unalignedWidth;      ///< Depth surface original width (of mip0)
-    UINT_32             unalignedHeight;     ///< Depth surface original height (of mip0)
-    UINT_32             numSlices;           ///< Depth surface original depth (of mip0)
-    UINT_32             numMipLevels;        ///< Depth surface total mipmap levels
-    UINT_32             numSamples;          ///< Depth surface number of samples
-    UINT_32             pipeXor;             ///< Pipe xor setting
-} ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeHtileCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
-{
-    UINT_32    size;        ///< Size of this structure in bytes
-
-    UINT_32    x;           ///< X coordinate
-    UINT_32    y;           ///< Y coordinate
-    UINT_32    slice;       ///< Index of slices
-    UINT_32    mipId;       ///< mipmap level id
-} ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeHtileCoordFromAddr
-*
-*   @brief
-*       Compute coordinates within depth buffer (1st pixel of a micro tile) according to
-*       Htile address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileCoordFromAddr(
-    ADDR_HANDLE                                       hLib,
-    const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT*    pIn,
-    ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT*         pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     C-mask functions for Gfx9
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_CMASK_INFO_INPUT
-*
-*   @brief
-*       Input structure of Addr2ComputeCmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_CMASKINFO_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-
-    ADDR2_META_FLAGS    cMaskFlags;         ///< CMASK flags
-    ADDR2_SURFACE_FLAGS colorFlags;         ///< Color surface flags
-    AddrResourceType    resourceType;       ///< Color surface type
-    AddrSwizzleMode     swizzleMode;        ///< FMask surface swizzle mode
-    UINT_32             unalignedWidth;     ///< Color surface original width
-    UINT_32             unalignedHeight;    ///< Color surface original height
-    UINT_32             numSlices;          ///< Number of slices of color buffer
-} ADDR2_COMPUTE_CMASK_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_CMASK_INFO_OUTPUT
-*
-*   @brief
-*       Output structure of Addr2ComputeCmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_CMASK_INFO_OUTPUT
-{
-    UINT_32    size;          ///< Size of this structure in bytes
-
-    UINT_32    pitch;         ///< Pitch in pixels of color buffer which
-                              ///  this Cmask matches. The size might be larger than
-                              ///  original color buffer pitch when called with
-                              ///  an unaligned pitch.
-    UINT_32    height;        ///< Height in pixels, as above
-    UINT_32    baseAlign;     ///< Base alignment
-    UINT_32    sliceSize;     ///< Slice size, in bytes.
-    UINT_32    cmaskBytes;    ///< Size in bytes of CMask buffer
-    UINT_32    metaBlkWidth;  ///< Meta block width
-    UINT_32    metaBlkHeight; ///< Meta block height
-
-    UINT_32    metaBlkNumPerSlice; ///< Number of metablock within one slice
-} ADDR2_COMPUTE_CMASK_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeCmaskInfo
-*
-*   @brief
-*       Compute Cmask pitch, height, base alignment and size in bytes from color buffer
-*       info
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskInfo(
-    ADDR_HANDLE                              hLib,
-    const ADDR2_COMPUTE_CMASK_INFO_INPUT*    pIn,
-    ADDR2_COMPUTE_CMASK_INFO_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeCmaskAddrFromCoord
-*
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
-{
-    UINT_32             size;                ///< Size of this structure in bytes
-
-    UINT_32             x;                   ///< X coordinate
-    UINT_32             y;                   ///< Y coordinate
-    UINT_32             slice;               ///< Index of slices
-
-    ADDR2_META_FLAGS    cMaskFlags;          ///< CMASK flags
-    ADDR2_SURFACE_FLAGS colorFlags;          ///< Color surface flags
-    AddrResourceType    resourceType;        ///< Color surface type
-    AddrSwizzleMode     swizzleMode;         ///< FMask surface swizzle mode
-
-    UINT_32             unalignedWidth;      ///< Color surface original width (of mip0)
-    UINT_32             unalignedHeight;     ///< Color surface original height (of mip0)
-    UINT_32             numSlices;           ///< Color surface original slices (of mip0)
-
-    UINT_32             numSamples;          ///< Color surfae sample number
-    UINT_32             numFrags;            ///< Color surface fragment number
-
-    UINT_32             pipeXor;             ///< pipe Xor setting
-} ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeCmaskAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32    size;           ///< Size of this structure in bytes
-
-    UINT_64    addr;           ///< CMASK address in bytes
-    UINT_32    bitPosition;    ///< Bit position within addr, 0 or 4
-} ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeCmaskAddrFromCoord
-*
-*   @brief
-*       Compute Cmask address according to coordinates (of MSAA color buffer)
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskAddrFromCoord(
-    ADDR_HANDLE                                      hLib,
-    const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT*   pIn,
-    ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT*        pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeCmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT
-{
-    UINT_32             size;                ///< Size of this structure in bytes
-
-    UINT_64             addr;                ///< CMASK address in bytes
-    UINT_32             bitPosition;         ///< Bit position within addr, 0 or 4
-
-    ADDR2_META_FLAGS    cMaskFlags;          ///< CMASK flags
-    ADDR2_SURFACE_FLAGS colorFlags;          ///< Color surface flags
-    AddrResourceType    resourceType;        ///< Color surface type
-    AddrSwizzleMode     swizzleMode;         ///< FMask surface swizzle mode
-
-    UINT_32             unalignedWidth;      ///< Color surface original width (of mip0)
-    UINT_32             unalignedHeight;     ///< Color surface original height (of mip0)
-    UINT_32             numSlices;           ///< Color surface original slices (of mip0)
-    UINT_32             numMipLevels;        ///< Color surface total mipmap levels.
-} ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeCmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
-{
-    UINT_32    size;        ///< Size of this structure in bytes
-
-    UINT_32    x;           ///< X coordinate
-    UINT_32    y;           ///< Y coordinate
-    UINT_32    slice;       ///< Index of slices
-    UINT_32    mipId;       ///< mipmap level id
-} ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeCmaskCoordFromAddr
-*
-*   @brief
-*       Compute coordinates within color buffer (1st pixel of a micro tile) according to
-*       Cmask address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskCoordFromAddr(
-    ADDR_HANDLE                                       hLib,
-    const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT*    pIn,
-    ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT*         pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     F-mask functions for Gfx9
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR2_FMASK_FLAGS
-*
-*   @brief
-*       FMASK flags
-****************************************************************************************************
-*/
-typedef union _ADDR2_FMASK_FLAGS
-{
-    struct
-    {
-        UINT_32 resolved :  1;    ///< TRUE if this is a resolved fmask, used by H/W clients
-                                  ///  by H/W clients. S/W should always set it to FALSE.
-        UINT_32 reserved : 31;    ///< Reserved for future use.
-    };
-
-    UINT_32 value;
-} ADDR2_FMASK_FLAGS;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_FMASK_INFO_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeFmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_FMASK_INFO_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-
-    AddrSwizzleMode     swizzleMode;        ///< FMask surface swizzle mode
-    UINT_32             unalignedWidth;     ///< Color surface original width
-    UINT_32             unalignedHeight;    ///< Color surface original height
-    UINT_32             numSlices;          ///< Number of slices/depth
-    UINT_32             numSamples;         ///< Number of samples
-    UINT_32             numFrags;           ///< Number of fragments, leave it zero or the same as
-                                            ///  number of samples for normal AA; Set it to the
-                                            ///  number of fragments for EQAA
-    ADDR2_FMASK_FLAGS   fMaskFlags;         ///< FMASK flags
-} ADDR2_COMPUTE_FMASK_INFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_FMASK_INFO_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeFmaskInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_FMASK_INFO_OUTPUT
-{
-    UINT_32    size;           ///< Size of this structure in bytes
-
-    UINT_32    pitch;          ///< Pitch of fmask in pixels
-    UINT_32    height;         ///< Height of fmask in pixels
-    UINT_32    baseAlign;      ///< Base alignment
-    UINT_32    numSlices;      ///< Slices of fmask
-    UINT_32    fmaskBytes;     ///< Size of fmask in bytes
-    UINT_32    bpp;            ///< Bits per pixel of FMASK is: number of bit planes
-    UINT_32    numSamples;     ///< Number of samples
-    UINT_32    sliceSize;      ///< Size of slice in bytes
-} ADDR2_COMPUTE_FMASK_INFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeFmaskInfo
-*
-*   @brief
-*       Compute Fmask pitch/height/slices/alignments and size in bytes
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskInfo(
-    ADDR_HANDLE                              hLib,
-    const ADDR2_COMPUTE_FMASK_INFO_INPUT*    pIn,
-    ADDR2_COMPUTE_FMASK_INFO_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeFmaskAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
-{
-    UINT_32            size;               ///< Size of this structure in bytes
-
-    AddrSwizzleMode    swizzleMode;        ///< FMask surface swizzle mode
-    UINT_32            x;                  ///< X coordinate
-    UINT_32            y;                  ///< Y coordinate
-    UINT_32            slice;              ///< Slice index
-    UINT_32            sample;             ///< Sample index (fragment index for EQAA)
-    UINT_32            plane;              ///< Plane number
-
-    UINT_32            unalignedWidth;     ///< Color surface original width
-    UINT_32            unalignedHeight;    ///< Color surface original height
-    UINT_32            numSamples;         ///< Number of samples
-    UINT_32            numFrags;           ///< Number of fragments, leave it zero or the same as
-                                           ///  number of samples for normal AA; Set it to the
-                                           ///  number of fragments for EQAA
-    UINT_32            tileSwizzle;        ///< Combined swizzle used to do bank/pipe rotation
-
-    ADDR2_FMASK_FLAGS  fMaskFlags; ///< FMASK flags
-} ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeFmaskAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32    size;           ///< Size of this structure in bytes
-
-    UINT_64    addr;           ///< Fmask address
-    UINT_32    bitPosition;    ///< Bit position within fmaskAddr, 0-7.
-} ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeFmaskAddrFromCoord
-*
-*   @brief
-*       Compute Fmask address according to coordinates (x,y,slice,sample,plane)
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskAddrFromCoord(
-    ADDR_HANDLE                                       hLib,
-    const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT*    pIn,
-    ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT*         pOut);
-
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeFmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT
-{
-    UINT_32            size;               ///< Size of this structure in bytes
-
-    UINT_64            addr;               ///< Address
-    UINT_32            bitPosition;        ///< Bit position within addr, 0-7.
-    AddrSwizzleMode    swizzleMode;        ///< FMask surface swizzle mode
-
-    UINT_32            unalignedWidth;     ///< Color surface original width
-    UINT_32            unalignedHeight;    ///< Color surface original height
-    UINT_32            numSamples;         ///< Number of samples
-    UINT_32            numFrags;           ///< Number of fragments
-
-    UINT_32            tileSwizzle;        ///< Combined swizzle used to do bank/pipe rotation
-
-    ADDR2_FMASK_FLAGS  fMaskFlags; ///< FMASK flags
-} ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeFmaskCoordFromAddr
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
-{
-    UINT_32    size;      ///< Size of this structure in bytes
-
-    UINT_32    x;         ///< X coordinate
-    UINT_32    y;         ///< Y coordinate
-    UINT_32    slice;     ///< Slice index
-    UINT_32    sample;    ///< Sample index (fragment index for EQAA)
-    UINT_32    plane;     ///< Plane number
-} ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeFmaskCoordFromAddr
-*
-*   @brief
-*       Compute FMASK coordinate from an given address
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskCoordFromAddr(
-    ADDR_HANDLE                                       hLib,
-    const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT*    pIn,
-    ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT*         pOut);
-
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     DCC key functions for Gfx9
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   _ADDR2_COMPUTE_DCCINFO_INPUT
-*
-*   @brief
-*       Input structure of Addr2ComputeDccInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_DCCINFO_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-
-    ADDR2_META_FLAGS    dccKeyFlags;        ///< DCC key flags
-    ADDR2_SURFACE_FLAGS colorFlags;         ///< Color surface flags
-    AddrResourceType    resourceType;       ///< Color surface type
-    AddrSwizzleMode     swizzleMode;        ///< Color surface swizzle mode
-    UINT_32             bpp;                ///< bits per pixel
-    UINT_32             unalignedWidth;     ///< Color surface original width (of mip0)
-    UINT_32             unalignedHeight;    ///< Color surface original height (of mip0)
-    UINT_32             numSlices;          ///< Number of slices, of color surface (of mip0)
-    UINT_32             numFrags;           ///< Fragment number of color surface
-    UINT_32             numMipLevels;       ///< Total mipmap levels of color surface
-    UINT_32             dataSurfaceSize;    ///< The padded size of all slices and mip levels
-                                            ///< useful in meta linear case
-    UINT_32             firstMipIdInTail;
-} ADDR2_COMPUTE_DCCINFO_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_DCCINFO_OUTPUT
-*
-*   @brief
-*       Output structure of Addr2ComputeDccInfo
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_DCCINFO_OUTPUT
-{
-    UINT_32    size;               ///< Size of this structure in bytes
-
-    UINT_32    dccRamBaseAlign;    ///< Base alignment of dcc key
-    UINT_32    dccRamSize;         ///< Size of dcc key
-
-    UINT_32    pitch;              ///< DCC surface mip chain pitch
-    UINT_32    height;             ///< DCC surface mip chain height
-    UINT_32    depth;              ///< DCC surface mip chain depth
-
-    UINT_32    compressBlkWidth;   ///< DCC compress block width
-    UINT_32    compressBlkHeight;  ///< DCC compress block height
-    UINT_32    compressBlkDepth;   ///< DCC compress block depth
-
-    UINT_32    metaBlkWidth;       ///< DCC meta block width
-    UINT_32    metaBlkHeight;      ///< DCC meta block height
-    UINT_32    metaBlkDepth;       ///< DCC meta block depth
-
-    UINT_32    metaBlkNumPerSlice; ///< Number of metablock within one slice
-
-    union
-    {
-        UINT_32 fastClearSizePerSlice;  ///< Size of DCC within a slice should be fast cleared
-        UINT_32 dccRamSliceSize;
-    };
-
-    ADDR2_META_MIP_INFO* pMipInfo;      ///< DCC mip information
-} ADDR2_COMPUTE_DCCINFO_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeDccInfo
-*
-*   @brief
-*       Compute DCC key size, base alignment
-*       info
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
-    ADDR_HANDLE                           hLib,
-    const ADDR2_COMPUTE_DCCINFO_INPUT*    pIn,
-    ADDR2_COMPUTE_DCCINFO_OUTPUT*         pOut);
-
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
-*
-*   @brief
-*       Input structure for Addr2ComputeDccAddrFromCoord
-*
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
-{
-    UINT_32             size;                ///< Size of this structure in bytes
-
-    UINT_32             x;                   ///< X coordinate
-    UINT_32             y;                   ///< Y coordinate
-    UINT_32             slice;               ///< Index of slices
-    UINT_32             sample;              ///< Index of samples, means fragment index for EQAA
-    UINT_32             mipId;               ///< mipmap level id
-
-    ADDR2_META_FLAGS    dccKeyFlags;         ///< DCC flags
-    ADDR2_SURFACE_FLAGS colorFlags;          ///< Color surface flags
-    AddrResourceType    resourceType;        ///< Color surface type
-    AddrSwizzleMode     swizzleMode;         ///< Color surface swizzle mode
-    UINT_32             bpp;                 ///< Color surface bits per pixel
-    UINT_32             unalignedWidth;      ///< Color surface original width (of mip0)
-    UINT_32             unalignedHeight;     ///< Color surface original height (of mip0)
-    UINT_32             numSlices;           ///< Color surface original slices (of mip0)
-    UINT_32             numMipLevels;        ///< Color surface mipmap levels
-    UINT_32             numFrags;            ///< Color surface fragment number
-
-    UINT_32             pipeXor;             ///< pipe Xor setting
-} ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
-*
-*   @brief
-*       Output structure for Addr2ComputeDccAddrFromCoord
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
-{
-    UINT_32    size;           ///< Size of this structure in bytes
-
-    UINT_64    addr;           ///< DCC address in bytes
-} ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeDccAddrFromCoord
-*
-*   @brief
-*       Compute DCC address according to coordinates (of MSAA color buffer)
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
-    ADDR_HANDLE                                    hLib,
-    const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT*   pIn,
-    ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT*        pOut);
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//                                     Misc functions for Gfx9
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_PIPEBANKXOR_INPUT
-*
-*   @brief
-*       Input structure of Addr2ComputePipebankXor
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_PIPEBANKXOR_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-    UINT_32             surfIndex;          ///< Input surface index
-    ADDR2_SURFACE_FLAGS flags;              ///< Surface flag
-    AddrSwizzleMode     swizzleMode;        ///< Surface swizzle mode
-    AddrResourceType    resourceType;       ///< Surface resource type
-    AddrFormat          format;             ///< Surface format
-    UINT_32             numSamples;         ///< Number of samples
-    UINT_32             numFrags;           ///< Number of fragments, leave it zero or the same as
-                                            ///  number of samples for normal AA; Set it to the
-                                            ///  number of fragments for EQAA
-} ADDR2_COMPUTE_PIPEBANKXOR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT
-*
-*   @brief
-*       Output structure of Addr2ComputePipebankXor
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-    UINT_32             pipeBankXor;        ///< Pipe bank xor
-} ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputePipeBankXor
-*
-*   @brief
-*       Calculate a valid bank pipe xor value for client to use.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
-    ADDR_HANDLE                            hLib,
-    const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
-    ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT*      pOut);
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
-*
-*   @brief
-*       Input structure of Addr2ComputeSlicePipeBankXor
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-    AddrSwizzleMode     swizzleMode;        ///< Surface swizzle mode
-    AddrResourceType    resourceType;       ///< Surface resource type
-    UINT_32             basePipeBankXor;    ///< Base pipe bank xor
-    UINT_32             slice;              ///< Slice id
-    UINT_32             numSamples;         ///< Number of samples
-} ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
-*
-*   @brief
-*       Output structure of Addr2ComputeSlicePipeBankXor
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-    UINT_32             pipeBankXor;        ///< Pipe bank xor
-} ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSlicePipeBankXor
-*
-*   @brief
-*       Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
-    ADDR_HANDLE                                  hLib,
-    const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
-    ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT*      pOut);
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
-*
-*   @brief
-*       Input structure of Addr2ComputeSubResourceOffsetForSwizzlePattern
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-    AddrSwizzleMode     swizzleMode;        ///< Surface swizzle mode
-    AddrResourceType    resourceType;       ///< Surface resource type
-    UINT_32             pipeBankXor;        ///< Per resource xor
-    UINT_32             slice;              ///< Slice id
-    UINT_64             sliceSize;          ///< Slice size of a mip chain
-    UINT_64             macroBlockOffset;   ///< Macro block offset, returned in ADDR2_MIP_INFO
-    UINT_32             mipTailOffset;      ///< Mip tail offset, returned in ADDR2_MIP_INFO
-} ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
-*
-*   @brief
-*       Output structure of Addr2ComputeSubResourceOffsetForSwizzlePattern
-****************************************************************************************************
-*/
-typedef struct _ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
-{
-    UINT_32             size;               ///< Size of this structure in bytes
-    UINT_64             offset;             ///< offset
-} ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2ComputeSubResourceOffsetForSwizzlePattern
-*
-*   @brief
-*       Calculate sub resource offset to support swizzle pattern.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
-    ADDR_HANDLE                                                     hLib,
-    const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
-    ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT*      pOut);
-
-/**
-****************************************************************************************************
-*   ADDR2_BLOCK_SET
-*
-*   @brief
-*       Bit field that defines block type
-****************************************************************************************************
-*/
-typedef union _ADDR2_BLOCK_SET
-{
-    struct
-    {
-        UINT_32 micro       : 1;   // 256B block for 2D resource
-        UINT_32 macro4KB    : 1;   // 4KB for 2D/3D resource
-        UINT_32 macro64KB   : 1;   // 64KB for 2D/3D resource
-        UINT_32 var         : 1;   // VAR block
-        UINT_32 linear      : 1;   // Linear block
-        UINT_32 reserved    : 27;
-    };
-
-    UINT_32 value;
-} ADDR2_BLOCK_SET;
-
-/**
-****************************************************************************************************
-*   ADDR2_SWTYPE_SET
-*
-*   @brief
-*       Bit field that defines swizzle type
-****************************************************************************************************
-*/
-typedef union _ADDR2_SWTYPE_SET
-{
-    struct
-    {
-        UINT_32 sw_Z     : 1;   // SW_*_Z_*
-        UINT_32 sw_S     : 1;   // SW_*_S_*
-        UINT_32 sw_D     : 1;   // SW_*_D_*
-        UINT_32 sw_R     : 1;   // SW_*_R_*
-        UINT_32 reserved : 28;
-    };
-
-    UINT_32 value;
-} ADDR2_SWTYPE_SET;
-
-/**
-****************************************************************************************************
-*   ADDR2_GET_PREFERRED_SURF_SETTING_INPUT
-*
-*   @brief
-*       Input structure of Addr2GetPreferredSurfaceSetting
-****************************************************************************************************
-*/
-typedef struct _ADDR2_GET_PREFERRED_SURF_SETTING_INPUT
-{
-    UINT_32               size;              ///< Size of this structure in bytes
-
-    ADDR2_SURFACE_FLAGS   flags;             ///< Surface flags
-    AddrResourceType      resourceType;      ///< Surface type
-    AddrFormat            format;            ///< Surface format
-    AddrResrouceLocation  resourceLoction;   ///< Surface heap choice
-    ADDR2_BLOCK_SET       forbiddenBlock;    ///< Client can use it to disable some block setting
-                                             ///< such as linear for DXTn, tiled for YUV
-    ADDR2_SWTYPE_SET      preferredSwSet;    ///< Client can use it to specify sw type(s) wanted
-    BOOL_32               noXor;             ///< Do not use xor mode for this resource
-    UINT_32               bpp;               ///< bits per pixel
-    UINT_32               width;             ///< Width (of mip0), in pixels
-    UINT_32               height;            ///< Height (of mip0), in pixels
-    UINT_32               numSlices;         ///< Number surface slice/depth (of mip0),
-    UINT_32               numMipLevels;      ///< Total mipmap levels.
-    UINT_32               numSamples;        ///< Number of samples
-    UINT_32               numFrags;          ///< Number of fragments, leave it zero or the same as
-                                             ///  number of samples for normal AA; Set it to the
-                                             ///  number of fragments for EQAA
-    UINT_32               maxAlign;          ///< maximum base/size alignment requested by client
-    UINT_32               minSizeAlign;      ///< memory allocated for surface in client driver will
-                                             ///  be padded to multiple of this value (in bytes)
-} ADDR2_GET_PREFERRED_SURF_SETTING_INPUT;
-
-/**
-****************************************************************************************************
-*   ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT
-*
-*   @brief
-*       Output structure of Addr2GetPreferredSurfaceSetting
-****************************************************************************************************
-*/
-typedef struct _ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT
-{
-    UINT_32               size;                 ///< Size of this structure in bytes
-
-    AddrSwizzleMode       swizzleMode;          ///< Suggested swizzle mode to be used
-    AddrResourceType      resourceType;         ///< Suggested resource type to program HW
-    ADDR2_BLOCK_SET       validBlockSet;        ///< Valid block type bit conbination
-    BOOL_32               canXor;               ///< If client can use xor on a valid macro block
-                                                ///  type
-    ADDR2_SWTYPE_SET      validSwTypeSet;       ///< Valid swizzle type bit combination
-    ADDR2_SWTYPE_SET      clientPreferredSwSet; ///< Client-preferred swizzle type bit combination
-} ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT;
-
-/**
-****************************************************************************************************
-*   Addr2GetPreferredSurfaceSetting
-*
-*   @brief
-*       Suggest a preferred setting for client driver to program HW register
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
-    ADDR_HANDLE                                   hLib,
-    const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
-    ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT*      pOut);
-
-/**
-****************************************************************************************************
-*   Addr2IsValidDisplaySwizzleMode
-*
-*   @brief
-*       Return whether the swizzle mode is supported by DCE / DCN.
-****************************************************************************************************
-*/
-ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
-    ADDR_HANDLE     hLib,
-    AddrSwizzleMode swizzleMode,
-    UINT_32         bpp,
-    bool            *result);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif // __ADDR_INTERFACE_H__
diff --git a/src/amd/addrlib/addrtypes.h b/src/amd/addrlib/addrtypes.h
deleted file mode 100644 (file)
index c63ad96..0000000
+++ /dev/null
@@ -1,749 +0,0 @@
-/*
- * 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  addrtypes.h
-* @brief Contains the helper function and constants
-****************************************************************************************************
-*/
-#ifndef __ADDR_TYPES_H__
-#define __ADDR_TYPES_H__
-
-#if defined(__APPLE__) && !defined(HAVE_TSERVER)
-// External definitions header maintained by Apple driver team, but not for diag team under Mac.
-// Helps address compilation issues & reduces code covered by NDA
-#include "addrExtDef.h"
-
-#else
-
-// Windows and/or Linux
-#if !defined(VOID)
-typedef void           VOID;
-#endif
-
-#if !defined(FLOAT)
-typedef float          FLOAT;
-#endif
-
-#if !defined(CHAR)
-typedef char           CHAR;
-#endif
-
-#if !defined(INT)
-typedef int            INT;
-#endif
-
-#include <stdarg.h> // va_list...etc need this header
-
-#endif // defined (__APPLE__) && !defined(HAVE_TSERVER)
-
-/**
-****************************************************************************************************
-*   Calling conventions
-****************************************************************************************************
-*/
-#ifndef ADDR_CDECL
-    #if defined(__GNUC__)
-        #define ADDR_CDECL __attribute__((cdecl))
-    #else
-        #define ADDR_CDECL __cdecl
-    #endif
-#endif
-
-#ifndef ADDR_STDCALL
-    #if defined(__GNUC__)
-        #if defined(__amd64__) || defined(__x86_64__)
-            #define ADDR_STDCALL
-        #else
-            #define ADDR_STDCALL __attribute__((stdcall))
-        #endif
-    #else
-        #define ADDR_STDCALL __stdcall
-    #endif
-#endif
-
-#ifndef ADDR_FASTCALL
-    #if defined(BRAHMA_ARM)
-        #define ADDR_FASTCALL
-    #elif defined(__GNUC__)
-        #if defined(__i386__)
-            #define ADDR_FASTCALL __attribute__((regparm(0)))
-        #else
-            #define ADDR_FASTCALL
-        #endif
-    #else
-        #define ADDR_FASTCALL __fastcall
-    #endif
-#endif
-
-#ifndef GC_CDECL
-    #define GC_CDECL  ADDR_CDECL
-#endif
-
-#ifndef GC_STDCALL
-    #define GC_STDCALL  ADDR_STDCALL
-#endif
-
-#ifndef GC_FASTCALL
-    #define GC_FASTCALL  ADDR_FASTCALL
-#endif
-
-
-#if defined(__GNUC__)
-    #define ADDR_INLINE static inline   // inline needs to be static to link
-#else
-    // win32, win64, other platforms
-    #define ADDR_INLINE   __inline
-#endif // #if defined(__GNUC__)
-
-#define ADDR_API ADDR_FASTCALL //default call convention is fast call
-
-/**
-****************************************************************************************************
-* Global defines used by other modules
-****************************************************************************************************
-*/
-#if !defined(TILEINDEX_INVALID)
-#define TILEINDEX_INVALID                -1
-#endif
-
-#if !defined(TILEINDEX_LINEAR_GENERAL)
-#define TILEINDEX_LINEAR_GENERAL         -2
-#endif
-
-#if !defined(TILEINDEX_LINEAR_ALIGNED)
-#define TILEINDEX_LINEAR_ALIGNED          8
-#endif
-
-/**
-****************************************************************************************************
-* Return codes
-****************************************************************************************************
-*/
-typedef enum _ADDR_E_RETURNCODE
-{
-    // General Return
-    ADDR_OK    = 0,
-    ADDR_ERROR = 1,
-
-    // Specific Errors
-    ADDR_OUTOFMEMORY,
-    ADDR_INVALIDPARAMS,
-    ADDR_NOTSUPPORTED,
-    ADDR_NOTIMPLEMENTED,
-    ADDR_PARAMSIZEMISMATCH,
-    ADDR_INVALIDGBREGVALUES,
-
-} ADDR_E_RETURNCODE;
-
-/**
-****************************************************************************************************
-* @brief
-*   Neutral enums that define tile modes for all H/W
-* @note
-*   R600/R800 tiling mode can be cast to hw enums directly but never cast into HW enum from
-*   ADDR_TM_2D_TILED_XTHICK
-*
-****************************************************************************************************
-*/
-typedef enum _AddrTileMode
-{
-    ADDR_TM_LINEAR_GENERAL      = 0,    ///< Least restrictions, pitch: multiple of 8 if not buffer
-    ADDR_TM_LINEAR_ALIGNED      = 1,    ///< Requests pitch or slice to be multiple of 64 pixels
-    ADDR_TM_1D_TILED_THIN1      = 2,    ///< Linear array of 8x8 tiles
-    ADDR_TM_1D_TILED_THICK      = 3,    ///< Linear array of 8x8x4 tiles
-    ADDR_TM_2D_TILED_THIN1      = 4,    ///< A set of macro tiles consist of 8x8 tiles
-    ADDR_TM_2D_TILED_THIN2      = 5,    ///< 600 HWL only, macro tile ratio is 1:4
-    ADDR_TM_2D_TILED_THIN4      = 6,    ///< 600 HWL only, macro tile ratio is 1:16
-    ADDR_TM_2D_TILED_THICK      = 7,    ///< A set of macro tiles consist of 8x8x4 tiles
-    ADDR_TM_2B_TILED_THIN1      = 8,    ///< 600 HWL only, with bank swap
-    ADDR_TM_2B_TILED_THIN2      = 9,    ///< 600 HWL only, with bank swap and ratio is 1:4
-    ADDR_TM_2B_TILED_THIN4      = 10,   ///< 600 HWL only, with bank swap and ratio is 1:16
-    ADDR_TM_2B_TILED_THICK      = 11,   ///< 600 HWL only, with bank swap, consists of 8x8x4 tiles
-    ADDR_TM_3D_TILED_THIN1      = 12,   ///< Macro tiling w/ pipe rotation between slices
-    ADDR_TM_3D_TILED_THICK      = 13,   ///< Macro tiling w/ pipe rotation bwtween slices, thick
-    ADDR_TM_3B_TILED_THIN1      = 14,   ///< 600 HWL only, with bank swap
-    ADDR_TM_3B_TILED_THICK      = 15,   ///< 600 HWL only, with bank swap, thick
-    ADDR_TM_2D_TILED_XTHICK     = 16,   ///< Tile is 8x8x8, valid from NI
-    ADDR_TM_3D_TILED_XTHICK     = 17,   ///< Tile is 8x8x8, valid from NI
-    ADDR_TM_POWER_SAVE          = 18,   ///< Power save mode, only used by KMD on NI
-    ADDR_TM_PRT_TILED_THIN1     = 19,   ///< No bank/pipe rotation or hashing beyond macrotile size
-    ADDR_TM_PRT_2D_TILED_THIN1  = 20,   ///< Same as 2D_TILED_THIN1, PRT only
-    ADDR_TM_PRT_3D_TILED_THIN1  = 21,   ///< Same as 3D_TILED_THIN1, PRT only
-    ADDR_TM_PRT_TILED_THICK     = 22,   ///< No bank/pipe rotation or hashing beyond macrotile size
-    ADDR_TM_PRT_2D_TILED_THICK  = 23,   ///< Same as 2D_TILED_THICK, PRT only
-    ADDR_TM_PRT_3D_TILED_THICK  = 24,   ///< Same as 3D_TILED_THICK, PRT only
-    ADDR_TM_UNKNOWN             = 25,   ///< Unkown tile mode, should be decided by address lib
-    ADDR_TM_COUNT               = 26,   ///< Must be the value of the last tile mode
-} AddrTileMode;
-
-/**
-****************************************************************************************************
-* @brief
-*   Neutral enums that define swizzle modes for Gfx9 ASIC
-* @note
-*
-*   ADDR_SW_LINEAR linear aligned addressing mode, for 1D/2D/3D resouce
-*   ADDR_SW_256B_* addressing block aligned size is 256B, for 2D/3D resouce
-*   ADDR_SW_4KB_*  addressing block aligned size is 4KB, for 2D/3D resouce
-*   ADDR_SW_64KB_* addressing block aligned size is 64KB, for 2D/3D resouce
-*   ADDR_SW_VAR_*  addressing block aligned size is ASIC specific, for 2D/3D resouce
-*
-*   ADDR_SW_*_Z    For 2D resouce, represents Z-order swizzle mode for depth/stencil/FMask
-                   For 3D resouce, represents a swizzle mode similar to legacy thick tile mode
-*   ADDR_SW_*_S    represents standard swizzle mode defined by MS
-*   ADDR_SW_*_D    For 2D resouce, represents a swizzle mode for displayable resource
-*                  For 3D resouce, represents a swizzle mode which places each slice in order & pixel
-                   within slice is placed as 2D ADDR_SW_*_S. Don't use this combination if possible!
-*   ADDR_SW_*_R    For 2D resouce only, represents a swizzle mode for rotated displayable resource
-*
-****************************************************************************************************
-*/
-typedef enum _AddrSwizzleMode
-{
-    ADDR_SW_LINEAR          = 0,
-    ADDR_SW_256B_S          = 1,
-    ADDR_SW_256B_D          = 2,
-    ADDR_SW_256B_R          = 3,
-    ADDR_SW_4KB_Z           = 4,
-    ADDR_SW_4KB_S           = 5,
-    ADDR_SW_4KB_D           = 6,
-    ADDR_SW_4KB_R           = 7,
-    ADDR_SW_64KB_Z          = 8,
-    ADDR_SW_64KB_S          = 9,
-    ADDR_SW_64KB_D          = 10,
-    ADDR_SW_64KB_R          = 11,
-    ADDR_SW_VAR_Z           = 12,
-    ADDR_SW_VAR_S           = 13,
-    ADDR_SW_VAR_D           = 14,
-    ADDR_SW_VAR_R           = 15,
-    ADDR_SW_64KB_Z_T        = 16,
-    ADDR_SW_64KB_S_T        = 17,
-    ADDR_SW_64KB_D_T        = 18,
-    ADDR_SW_64KB_R_T        = 19,
-    ADDR_SW_4KB_Z_X         = 20,
-    ADDR_SW_4KB_S_X         = 21,
-    ADDR_SW_4KB_D_X         = 22,
-    ADDR_SW_4KB_R_X         = 23,
-    ADDR_SW_64KB_Z_X        = 24,
-    ADDR_SW_64KB_S_X        = 25,
-    ADDR_SW_64KB_D_X        = 26,
-    ADDR_SW_64KB_R_X        = 27,
-    ADDR_SW_VAR_Z_X         = 28,
-    ADDR_SW_VAR_S_X         = 29,
-    ADDR_SW_VAR_D_X         = 30,
-    ADDR_SW_VAR_R_X         = 31,
-    ADDR_SW_LINEAR_GENERAL  = 32,
-    ADDR_SW_MAX_TYPE        = 33,
-
-    // Used for represent block with identical size
-    ADDR_SW_256B            = ADDR_SW_256B_S,
-    ADDR_SW_4KB             = ADDR_SW_4KB_S_X,
-    ADDR_SW_64KB            = ADDR_SW_64KB_S_X,
-    ADDR_SW_VAR             = ADDR_SW_VAR_S_X,
-} AddrSwizzleMode;
-
-/**
-****************************************************************************************************
-* @brief
-*   Neutral enums that define image type
-* @note
-*   this is new for address library interface version 2
-*
-****************************************************************************************************
-*/
-typedef enum _AddrResourceType
-{
-    ADDR_RSRC_TEX_1D = 0,
-    ADDR_RSRC_TEX_2D = 1,
-    ADDR_RSRC_TEX_3D = 2,
-    ADDR_RSRC_MAX_TYPE = 3,
-} AddrResourceType;
-
-/**
-****************************************************************************************************
-* @brief
-*   Neutral enums that define resource heap location
-* @note
-*   this is new for address library interface version 2
-*
-****************************************************************************************************
-*/
-typedef enum _AddrResrouceLocation
-{
-    ADDR_RSRC_LOC_UNDEF  = 0,   // Resource heap is undefined/unknown
-    ADDR_RSRC_LOC_LOCAL  = 1,   // CPU visable and CPU invisable local heap
-    ADDR_RSRC_LOC_USWC   = 2,   // CPU write-combined non-cached nonlocal heap
-    ADDR_RSRC_LOC_CACHED = 3,   // CPU cached nonlocal heap
-    ADDR_RSRC_LOC_INVIS  = 4,   // CPU invisable local heap only
-    ADDR_RSRC_LOC_MAX_TYPE = 5,
-} AddrResrouceLocation;
-
-/**
-****************************************************************************************************
-* @brief
-*   Neutral enums that define resource basic swizzle mode
-* @note
-*   this is new for address library interface version 2
-*
-****************************************************************************************************
-*/
-typedef enum _AddrSwType
-{
-    ADDR_SW_Z  = 0,   // Resource basic swizzle mode is ZOrder
-    ADDR_SW_S  = 1,   // Resource basic swizzle mode is Standard
-    ADDR_SW_D  = 2,   // Resource basic swizzle mode is Display
-    ADDR_SW_R  = 3,   // Resource basic swizzle mode is Rotated
-} AddrSwType;
-
-/**
-****************************************************************************************************
-* @brief
-*   Neutral enums that define mipmap major mode
-* @note
-*   this is new for address library interface version 2
-*
-****************************************************************************************************
-*/
-typedef enum _AddrMajorMode
-{
-    ADDR_MAJOR_X = 0,
-    ADDR_MAJOR_Y = 1,
-    ADDR_MAJOR_Z = 2,
-    ADDR_MAJOR_MAX_TYPE = 3,
-} AddrMajorMode;
-
-/**
-****************************************************************************************************
-*   AddrFormat
-*
-*   @brief
-*       Neutral enum for SurfaceFormat
-*
-****************************************************************************************************
-*/
-typedef enum _AddrFormat {
-    ADDR_FMT_INVALID                              = 0x00000000,
-    ADDR_FMT_8                                    = 0x00000001,
-    ADDR_FMT_4_4                                  = 0x00000002,
-    ADDR_FMT_3_3_2                                = 0x00000003,
-    ADDR_FMT_RESERVED_4                           = 0x00000004,
-    ADDR_FMT_16                                   = 0x00000005,
-    ADDR_FMT_16_FLOAT                             = 0x00000006,
-    ADDR_FMT_8_8                                  = 0x00000007,
-    ADDR_FMT_5_6_5                                = 0x00000008,
-    ADDR_FMT_6_5_5                                = 0x00000009,
-    ADDR_FMT_1_5_5_5                              = 0x0000000a,
-    ADDR_FMT_4_4_4_4                              = 0x0000000b,
-    ADDR_FMT_5_5_5_1                              = 0x0000000c,
-    ADDR_FMT_32                                   = 0x0000000d,
-    ADDR_FMT_32_FLOAT                             = 0x0000000e,
-    ADDR_FMT_16_16                                = 0x0000000f,
-    ADDR_FMT_16_16_FLOAT                          = 0x00000010,
-    ADDR_FMT_8_24                                 = 0x00000011,
-    ADDR_FMT_8_24_FLOAT                           = 0x00000012,
-    ADDR_FMT_24_8                                 = 0x00000013,
-    ADDR_FMT_24_8_FLOAT                           = 0x00000014,
-    ADDR_FMT_10_11_11                             = 0x00000015,
-    ADDR_FMT_10_11_11_FLOAT                       = 0x00000016,
-    ADDR_FMT_11_11_10                             = 0x00000017,
-    ADDR_FMT_11_11_10_FLOAT                       = 0x00000018,
-    ADDR_FMT_2_10_10_10                           = 0x00000019,
-    ADDR_FMT_8_8_8_8                              = 0x0000001a,
-    ADDR_FMT_10_10_10_2                           = 0x0000001b,
-    ADDR_FMT_X24_8_32_FLOAT                       = 0x0000001c,
-    ADDR_FMT_32_32                                = 0x0000001d,
-    ADDR_FMT_32_32_FLOAT                          = 0x0000001e,
-    ADDR_FMT_16_16_16_16                          = 0x0000001f,
-    ADDR_FMT_16_16_16_16_FLOAT                    = 0x00000020,
-    ADDR_FMT_RESERVED_33                          = 0x00000021,
-    ADDR_FMT_32_32_32_32                          = 0x00000022,
-    ADDR_FMT_32_32_32_32_FLOAT                    = 0x00000023,
-    ADDR_FMT_RESERVED_36                          = 0x00000024,
-    ADDR_FMT_1                                    = 0x00000025,
-    ADDR_FMT_1_REVERSED                           = 0x00000026,
-    ADDR_FMT_GB_GR                                = 0x00000027,
-    ADDR_FMT_BG_RG                                = 0x00000028,
-    ADDR_FMT_32_AS_8                              = 0x00000029,
-    ADDR_FMT_32_AS_8_8                            = 0x0000002a,
-    ADDR_FMT_5_9_9_9_SHAREDEXP                    = 0x0000002b,
-    ADDR_FMT_8_8_8                                = 0x0000002c,
-    ADDR_FMT_16_16_16                             = 0x0000002d,
-    ADDR_FMT_16_16_16_FLOAT                       = 0x0000002e,
-    ADDR_FMT_32_32_32                             = 0x0000002f,
-    ADDR_FMT_32_32_32_FLOAT                       = 0x00000030,
-    ADDR_FMT_BC1                                  = 0x00000031,
-    ADDR_FMT_BC2                                  = 0x00000032,
-    ADDR_FMT_BC3                                  = 0x00000033,
-    ADDR_FMT_BC4                                  = 0x00000034,
-    ADDR_FMT_BC5                                  = 0x00000035,
-    ADDR_FMT_BC6                                  = 0x00000036,
-    ADDR_FMT_BC7                                  = 0x00000037,
-    ADDR_FMT_32_AS_32_32_32_32                    = 0x00000038,
-    ADDR_FMT_APC3                                 = 0x00000039,
-    ADDR_FMT_APC4                                 = 0x0000003a,
-    ADDR_FMT_APC5                                 = 0x0000003b,
-    ADDR_FMT_APC6                                 = 0x0000003c,
-    ADDR_FMT_APC7                                 = 0x0000003d,
-    ADDR_FMT_CTX1                                 = 0x0000003e,
-    ADDR_FMT_RESERVED_63                          = 0x0000003f,
-    ADDR_FMT_ASTC_4x4                             = 0x00000040,
-    ADDR_FMT_ASTC_5x4                             = 0x00000041,
-    ADDR_FMT_ASTC_5x5                             = 0x00000042,
-    ADDR_FMT_ASTC_6x5                             = 0x00000043,
-    ADDR_FMT_ASTC_6x6                             = 0x00000044,
-    ADDR_FMT_ASTC_8x5                             = 0x00000045,
-    ADDR_FMT_ASTC_8x6                             = 0x00000046,
-    ADDR_FMT_ASTC_8x8                             = 0x00000047,
-    ADDR_FMT_ASTC_10x5                            = 0x00000048,
-    ADDR_FMT_ASTC_10x6                            = 0x00000049,
-    ADDR_FMT_ASTC_10x8                            = 0x0000004a,
-    ADDR_FMT_ASTC_10x10                           = 0x0000004b,
-    ADDR_FMT_ASTC_12x10                           = 0x0000004c,
-    ADDR_FMT_ASTC_12x12                           = 0x0000004d,
-    ADDR_FMT_ETC2_64BPP                           = 0x0000004e,
-    ADDR_FMT_ETC2_128BPP                          = 0x0000004f,
-} AddrFormat;
-
-/**
-****************************************************************************************************
-*   AddrDepthFormat
-*
-*   @brief
-*       Neutral enum for addrFlt32ToDepthPixel
-*
-****************************************************************************************************
-*/
-typedef enum _AddrDepthFormat
-{
-    ADDR_DEPTH_INVALID                            = 0x00000000,
-    ADDR_DEPTH_16                                 = 0x00000001,
-    ADDR_DEPTH_X8_24                              = 0x00000002,
-    ADDR_DEPTH_8_24                               = 0x00000003,
-    ADDR_DEPTH_X8_24_FLOAT                        = 0x00000004,
-    ADDR_DEPTH_8_24_FLOAT                         = 0x00000005,
-    ADDR_DEPTH_32_FLOAT                           = 0x00000006,
-    ADDR_DEPTH_X24_8_32_FLOAT                     = 0x00000007,
-
-} AddrDepthFormat;
-
-/**
-****************************************************************************************************
-*   AddrColorFormat
-*
-*   @brief
-*       Neutral enum for ColorFormat
-*
-****************************************************************************************************
-*/
-typedef enum _AddrColorFormat
-{
-    ADDR_COLOR_INVALID                            = 0x00000000,
-    ADDR_COLOR_8                                  = 0x00000001,
-    ADDR_COLOR_4_4                                = 0x00000002,
-    ADDR_COLOR_3_3_2                              = 0x00000003,
-    ADDR_COLOR_RESERVED_4                         = 0x00000004,
-    ADDR_COLOR_16                                 = 0x00000005,
-    ADDR_COLOR_16_FLOAT                           = 0x00000006,
-    ADDR_COLOR_8_8                                = 0x00000007,
-    ADDR_COLOR_5_6_5                              = 0x00000008,
-    ADDR_COLOR_6_5_5                              = 0x00000009,
-    ADDR_COLOR_1_5_5_5                            = 0x0000000a,
-    ADDR_COLOR_4_4_4_4                            = 0x0000000b,
-    ADDR_COLOR_5_5_5_1                            = 0x0000000c,
-    ADDR_COLOR_32                                 = 0x0000000d,
-    ADDR_COLOR_32_FLOAT                           = 0x0000000e,
-    ADDR_COLOR_16_16                              = 0x0000000f,
-    ADDR_COLOR_16_16_FLOAT                        = 0x00000010,
-    ADDR_COLOR_8_24                               = 0x00000011,
-    ADDR_COLOR_8_24_FLOAT                         = 0x00000012,
-    ADDR_COLOR_24_8                               = 0x00000013,
-    ADDR_COLOR_24_8_FLOAT                         = 0x00000014,
-    ADDR_COLOR_10_11_11                           = 0x00000015,
-    ADDR_COLOR_10_11_11_FLOAT                     = 0x00000016,
-    ADDR_COLOR_11_11_10                           = 0x00000017,
-    ADDR_COLOR_11_11_10_FLOAT                     = 0x00000018,
-    ADDR_COLOR_2_10_10_10                         = 0x00000019,
-    ADDR_COLOR_8_8_8_8                            = 0x0000001a,
-    ADDR_COLOR_10_10_10_2                         = 0x0000001b,
-    ADDR_COLOR_X24_8_32_FLOAT                     = 0x0000001c,
-    ADDR_COLOR_32_32                              = 0x0000001d,
-    ADDR_COLOR_32_32_FLOAT                        = 0x0000001e,
-    ADDR_COLOR_16_16_16_16                        = 0x0000001f,
-    ADDR_COLOR_16_16_16_16_FLOAT                  = 0x00000020,
-    ADDR_COLOR_RESERVED_33                        = 0x00000021,
-    ADDR_COLOR_32_32_32_32                        = 0x00000022,
-    ADDR_COLOR_32_32_32_32_FLOAT                  = 0x00000023,
-} AddrColorFormat;
-
-/**
-****************************************************************************************************
-*   AddrSurfaceNumber
-*
-*   @brief
-*       Neutral enum for SurfaceNumber
-*
-****************************************************************************************************
-*/
-typedef enum _AddrSurfaceNumber {
-    ADDR_NUMBER_UNORM                             = 0x00000000,
-    ADDR_NUMBER_SNORM                             = 0x00000001,
-    ADDR_NUMBER_USCALED                           = 0x00000002,
-    ADDR_NUMBER_SSCALED                           = 0x00000003,
-    ADDR_NUMBER_UINT                              = 0x00000004,
-    ADDR_NUMBER_SINT                              = 0x00000005,
-    ADDR_NUMBER_SRGB                              = 0x00000006,
-    ADDR_NUMBER_FLOAT                             = 0x00000007,
-} AddrSurfaceNumber;
-
-/**
-****************************************************************************************************
-*   AddrSurfaceSwap
-*
-*   @brief
-*       Neutral enum for SurfaceSwap
-*
-****************************************************************************************************
-*/
-typedef enum _AddrSurfaceSwap {
-    ADDR_SWAP_STD                                 = 0x00000000,
-    ADDR_SWAP_ALT                                 = 0x00000001,
-    ADDR_SWAP_STD_REV                             = 0x00000002,
-    ADDR_SWAP_ALT_REV                             = 0x00000003,
-} AddrSurfaceSwap;
-
-/**
-****************************************************************************************************
-*   AddrHtileBlockSize
-*
-*   @brief
-*       Size of HTILE blocks, valid values are 4 or 8 for now
-****************************************************************************************************
-*/
-typedef enum _AddrHtileBlockSize
-{
-    ADDR_HTILE_BLOCKSIZE_4 = 4,
-    ADDR_HTILE_BLOCKSIZE_8 = 8,
-} AddrHtileBlockSize;
-
-
-/**
-****************************************************************************************************
-*   AddrPipeCfg
-*
-*   @brief
-*       The pipe configuration field specifies both the number of pipes and
-*       how pipes are interleaved on the surface.
-*       The expression of number of pipes, the shader engine tile size, and packer tile size
-*       is encoded in a PIPE_CONFIG register field.
-*       In general the number of pipes usually matches the number of memory channels of the
-*       hardware configuration.
-*       For hw configurations w/ non-pow2 memory number of memory channels, it usually matches
-*       the number of ROP units(? TODO: which registers??)
-*       The enum value = hw enum + 1 which is to reserve 0 for requesting default.
-****************************************************************************************************
-*/
-typedef enum _AddrPipeCfg
-{
-    ADDR_PIPECFG_INVALID         = 0,
-    ADDR_PIPECFG_P2              = 1, /// 2 pipes,
-    ADDR_PIPECFG_P4_8x16         = 5, /// 4 pipes,
-    ADDR_PIPECFG_P4_16x16        = 6,
-    ADDR_PIPECFG_P4_16x32        = 7,
-    ADDR_PIPECFG_P4_32x32        = 8,
-    ADDR_PIPECFG_P8_16x16_8x16   = 9, /// 8 pipes
-    ADDR_PIPECFG_P8_16x32_8x16   = 10,
-    ADDR_PIPECFG_P8_32x32_8x16   = 11,
-    ADDR_PIPECFG_P8_16x32_16x16  = 12,
-    ADDR_PIPECFG_P8_32x32_16x16  = 13,
-    ADDR_PIPECFG_P8_32x32_16x32  = 14,
-    ADDR_PIPECFG_P8_32x64_32x32  = 15,
-    ADDR_PIPECFG_P16_32x32_8x16  = 17, /// 16 pipes
-    ADDR_PIPECFG_P16_32x32_16x16 = 18,
-    ADDR_PIPECFG_MAX             = 19,
-} AddrPipeCfg;
-
-/**
-****************************************************************************************************
-* AddrTileType
-*
-*   @brief
-*       Neutral enums that specifies micro tile type (MICRO_TILE_MODE)
-****************************************************************************************************
-*/
-typedef enum _AddrTileType
-{
-    ADDR_DISPLAYABLE        = 0,    ///< Displayable tiling
-    ADDR_NON_DISPLAYABLE    = 1,    ///< Non-displayable tiling, a.k.a thin micro tiling
-    ADDR_DEPTH_SAMPLE_ORDER = 2,    ///< Same as non-displayable plus depth-sample-order
-    ADDR_ROTATED            = 3,    ///< Rotated displayable tiling
-    ADDR_THICK              = 4,    ///< Thick micro-tiling, only valid for THICK and XTHICK
-} AddrTileType;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Type definitions: short system-independent names for address library types
-//
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#if !defined(__APPLE__) || defined(HAVE_TSERVER)
-
-#ifndef BOOL_32        // no bool type in C
-/// @brief Boolean type, since none is defined in C
-/// @ingroup type
-#define BOOL_32 int
-#endif
-
-#ifndef INT_32
-#define INT_32  int
-#endif
-
-#ifndef UINT_32
-#define UINT_32 unsigned int
-#endif
-
-#ifndef INT_16
-#define INT_16  short
-#endif
-
-#ifndef UINT_16
-#define UINT_16 unsigned short
-#endif
-
-#ifndef INT_8
-#define INT_8   char
-#endif
-
-#ifndef UINT_8
-#define UINT_8  unsigned char
-#endif
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-
-#ifndef FALSE
-#define FALSE 0
-#endif
-
-//
-//  64-bit integer types depend on the compiler
-//
-#if defined( __GNUC__ ) || defined( __WATCOMC__ )
-#define INT_64   long long
-#define UINT_64  unsigned long long
-
-#elif defined( _WIN32 )
-#define INT_64   __int64
-#define UINT_64  unsigned __int64
-
-#else
-#error Unsupported compiler and/or operating system for 64-bit integers
-
-/// @brief 64-bit signed integer type (compiler dependent)
-/// @ingroup type
-///
-/// The addrlib defines a 64-bit signed integer type for either
-/// Gnu/Watcom compilers (which use the first syntax) or for
-/// the Windows VCC compiler (which uses the second syntax).
-#define INT_64  long long OR __int64
-
-/// @brief 64-bit unsigned integer type (compiler dependent)
-/// @ingroup type
-///
-/// The addrlib defines a 64-bit unsigned integer type for either
-/// Gnu/Watcom compilers (which use the first syntax) or for
-/// the Windows VCC compiler (which uses the second syntax).
-///
-#define UINT_64  unsigned long long OR unsigned __int64
-#endif
-
-#endif // #if !defined(__APPLE__) || defined(HAVE_TSERVER)
-
-//  ADDR64X is used to print addresses in hex form on both Windows and Linux
-//
-#if defined( __GNUC__ ) || defined( __WATCOMC__ )
-#define ADDR64X "llx"
-#define ADDR64D "lld"
-
-#elif defined( _WIN32 )
-#define ADDR64X "I64x"
-#define ADDR64D "I64d"
-
-#else
-#error Unsupported compiler and/or operating system for 64-bit integers
-
-/// @brief Addrlib device address 64-bit printf tag  (compiler dependent)
-/// @ingroup type
-///
-/// This allows printf to display an ADDR_64 for either the Windows VCC compiler
-/// (which used this value) or the Gnu/Watcom compilers (which use "llx".
-/// An example of use is printf("addr 0x%"ADDR64X"\n", address);
-///
-#define ADDR64X "llx" OR "I64x"
-#define ADDR64D "lld" OR "I64d"
-#endif
-
-
-/// @brief Union for storing a 32-bit float or 32-bit integer
-/// @ingroup type
-///
-/// This union provides a simple way to convert between a 32-bit float
-/// and a 32-bit integer. It also prevents the compiler from producing
-/// code that alters NaN values when assiging or coying floats.
-/// Therefore, all address library routines that pass or return 32-bit
-/// floating point data do so by passing or returning a FLT_32.
-///
-typedef union {
-    INT_32   i;
-    UINT_32  u;
-    float    f;
-} ADDR_FLT_32;
-
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-//  Macros for controlling linking and building on multiple systems
-//
-////////////////////////////////////////////////////////////////////////////////////////////////////
-#if defined(_MSC_VER)
-#if defined(va_copy)
-#undef va_copy  //redefine va_copy to support VC2013
-#endif
-#endif
-
-#if !defined(va_copy)
-#define va_copy(dst, src) \
-    ((void) memcpy(&(dst), &(src), sizeof(va_list)))
-#endif
-
-#endif // __ADDR_TYPES_H__
-
diff --git a/src/amd/addrlib/amdgpu_asic_addr.h b/src/amd/addrlib/amdgpu_asic_addr.h
deleted file mode 100644 (file)
index 7436c54..0000000
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright © 2017 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.
- */
-
-#ifndef _AMDGPU_ASIC_ADDR_H
-#define _AMDGPU_ASIC_ADDR_H
-
-#define ATI_VENDOR_ID         0x1002
-#define AMD_VENDOR_ID         0x1022
-
-// AMDGPU_VENDOR_IS_AMD(vendorId)
-#define AMDGPU_VENDOR_IS_AMD(v) ((v == ATI_VENDOR_ID) || (v == AMD_VENDOR_ID))
-
-#define FAMILY_UNKNOWN 0x00
-#define FAMILY_TN      0x69
-#define FAMILY_SI      0x6E
-#define FAMILY_CI      0x78
-#define FAMILY_KV      0x7D
-#define FAMILY_VI      0x82
-#define FAMILY_POLARIS 0x82
-#define FAMILY_CZ      0x87
-#define FAMILY_AI      0x8D
-#define FAMILY_RV      0x8E
-
-// AMDGPU_FAMILY_IS(familyId, familyName)
-#define FAMILY_IS(f, fn)     (f == FAMILY_##fn)
-#define FAMILY_IS_TN(f)      FAMILY_IS(f, TN)
-#define FAMILY_IS_SI(f)      FAMILY_IS(f, SI)
-#define FAMILY_IS_CI(f)      FAMILY_IS(f, CI)
-#define FAMILY_IS_KV(f)      FAMILY_IS(f, KV)
-#define FAMILY_IS_VI(f)      FAMILY_IS(f, VI)
-#define FAMILY_IS_POLARIS(f) FAMILY_IS(f, POLARIS)
-#define FAMILY_IS_CZ(f)      FAMILY_IS(f, CZ)
-#define FAMILY_IS_AI(f)      FAMILY_IS(f, AI)
-#define FAMILY_IS_RV(f)      FAMILY_IS(f, RV)
-
-#define AMDGPU_UNKNOWN          0xFF
-
-#define AMDGPU_TAHITI_RANGE     0x05, 0x14
-#define AMDGPU_PITCAIRN_RANGE   0x15, 0x28
-#define AMDGPU_CAPEVERDE_RANGE  0x29, 0x3C
-#define AMDGPU_OLAND_RANGE      0x3C, 0x46
-#define AMDGPU_HAINAN_RANGE     0x46, 0xFF
-
-#define AMDGPU_BONAIRE_RANGE    0x14, 0x28
-#define AMDGPU_HAWAII_RANGE     0x28, 0x3C
-
-#define AMDGPU_SPECTRE_RANGE    0x01, 0x41
-#define AMDGPU_SPOOKY_RANGE     0x41, 0x81
-#define AMDGPU_KALINDI_RANGE    0x81, 0xA1
-#define AMDGPU_GODAVARI_RANGE   0xA1, 0xFF
-
-#define AMDGPU_ICELAND_RANGE    0x01, 0x14
-#define AMDGPU_TONGA_RANGE      0x14, 0x28
-#define AMDGPU_FIJI_RANGE       0x3C, 0x50
-
-#define AMDGPU_POLARIS10_RANGE  0x50, 0x5A
-#define AMDGPU_POLARIS11_RANGE  0x5A, 0x64
-#define AMDGPU_POLARIS12_RANGE  0x64, 0x6E
-#define AMDGPU_VEGAM_RANGE      0x6E, 0xFF
-
-#define AMDGPU_CARRIZO_RANGE    0x01, 0x21
-#define AMDGPU_BRISTOL_RANGE    0x10, 0x21
-#define AMDGPU_STONEY_RANGE     0x61, 0xFF
-
-#define AMDGPU_VEGA10_RANGE     0x01, 0x14
-#define AMDGPU_VEGA12_RANGE     0x14, 0x28
-#define AMDGPU_VEGA20_RANGE     0x28, 0xFF
-
-#define AMDGPU_RAVEN_RANGE      0x01, 0x81
-#define AMDGPU_RAVEN2_RANGE     0x81, 0xFF
-
-#define AMDGPU_EXPAND_FIX(x) x
-#define AMDGPU_RANGE_HELPER(val, min, max) ((val >= min) && (val < max))
-#define AMDGPU_IN_RANGE(val, ...)   AMDGPU_EXPAND_FIX(AMDGPU_RANGE_HELPER(val, __VA_ARGS__))
-
-
-// ASICREV_IS(eRevisionId, revisionName)
-#define ASICREV_IS(r, rn)              AMDGPU_IN_RANGE(r, AMDGPU_##rn##_RANGE)
-#define ASICREV_IS_TAHITI_P(r)         ASICREV_IS(r, TAHITI)
-#define ASICREV_IS_PITCAIRN_PM(r)      ASICREV_IS(r, PITCAIRN)
-#define ASICREV_IS_CAPEVERDE_M(r)      ASICREV_IS(r, CAPEVERDE)
-#define ASICREV_IS_OLAND_M(r)          ASICREV_IS(r, OLAND)
-#define ASICREV_IS_HAINAN_V(r)         ASICREV_IS(r, HAINAN)
-
-#define ASICREV_IS_BONAIRE_M(r)        ASICREV_IS(r, BONAIRE)
-#define ASICREV_IS_HAWAII_P(r)         ASICREV_IS(r, HAWAII)
-
-#define ASICREV_IS_SPECTRE(r)          ASICREV_IS(r, SPECTRE)
-#define ASICREV_IS_SPOOKY(r)           ASICREV_IS(r, SPOOKY)
-#define ASICREV_IS_KALINDI(r)          ASICREV_IS(r, KALINDI)
-#define ASICREV_IS_KALINDI_GODAVARI(r) ASICREV_IS(r, GODAVARI)
-
-#define ASICREV_IS_ICELAND_M(r)        ASICREV_IS(r, ICELAND)
-#define ASICREV_IS_TONGA_P(r)          ASICREV_IS(r, TONGA)
-#define ASICREV_IS_FIJI_P(r)           ASICREV_IS(r, FIJI)
-
-#define ASICREV_IS_POLARIS10_P(r)      ASICREV_IS(r, POLARIS10)
-#define ASICREV_IS_POLARIS11_M(r)      ASICREV_IS(r, POLARIS11)
-#define ASICREV_IS_POLARIS12_V(r)      ASICREV_IS(r, POLARIS12)
-#define ASICREV_IS_VEGAM_P(r)          ASICREV_IS(r, VEGAM)
-
-#define ASICREV_IS_CARRIZO(r)          ASICREV_IS(r, CARRIZO)
-#define ASICREV_IS_CARRIZO_BRISTOL(r)  ASICREV_IS(r, BRISTOL)
-#define ASICREV_IS_STONEY(r)           ASICREV_IS(r, STONEY)
-
-#define ASICREV_IS_VEGA10_M(r)         ASICREV_IS(r, VEGA10)
-#define ASICREV_IS_VEGA10_P(r)         ASICREV_IS(r, VEGA10)
-#define ASICREV_IS_VEGA12_P(r)         ASICREV_IS(r, VEGA12)
-#define ASICREV_IS_VEGA12_p(r)         ASICREV_IS(r, VEGA12)
-#define ASICREV_IS_VEGA20_P(r)         ASICREV_IS(r, VEGA20)
-
-#define ASICREV_IS_RAVEN(r)            ASICREV_IS(r, RAVEN)
-#define ASICREV_IS_RAVEN2(r)           ASICREV_IS(r, RAVEN2)
-
-#endif // _AMDGPU_ASIC_ADDR_H
diff --git a/src/amd/addrlib/core/addrcommon.h b/src/amd/addrlib/core/addrcommon.h
deleted file mode 100644 (file)
index 99bb62e..0000000
+++ /dev/null
@@ -1,924 +0,0 @@
-/*
- * 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  addrcommon.h
-* @brief Contains the helper function and constants.
-****************************************************************************************************
-*/
-
-#ifndef __ADDR_COMMON_H__
-#define __ADDR_COMMON_H__
-
-#include "addrinterface.h"
-
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-#if !defined(DEBUG)
-#ifdef NDEBUG
-#define DEBUG 0
-#else
-#define DEBUG 1
-#endif
-#endif
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Platform specific debug break defines
-////////////////////////////////////////////////////////////////////////////////////////////////////
-#if DEBUG
-    #if defined(__GNUC__)
-        #define ADDR_DBG_BREAK()    assert(false)
-    #elif defined(__APPLE__)
-        #define ADDR_DBG_BREAK()    { IOPanic("");}
-    #else
-        #define ADDR_DBG_BREAK()    { __debugbreak(); }
-    #endif
-#else
-    #define ADDR_DBG_BREAK()
-#endif
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Debug assertions used in AddrLib
-////////////////////////////////////////////////////////////////////////////////////////////////////
-#if defined(_WIN32) && (_MSC_VER >= 1400)
-    #define ADDR_ANALYSIS_ASSUME(expr) __analysis_assume(expr)
-#else
-    #define ADDR_ANALYSIS_ASSUME(expr) do { (void)(expr); } while (0)
-#endif
-
-#define ADDR_ASSERT(__e) assert(__e)
-#define ADDR_ASSERT_ALWAYS() ADDR_DBG_BREAK()
-#define ADDR_UNHANDLED_CASE() ADDR_ASSERT(!"Unhandled case")
-#define ADDR_NOT_IMPLEMENTED() ADDR_ASSERT(!"Not implemented");
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Debug print macro from legacy address library
-////////////////////////////////////////////////////////////////////////////////////////////////////
-#if DEBUG
-
-#define ADDR_PRNT(a)    Object::DebugPrint a
-
-/// @brief Macro for reporting informational messages
-/// @ingroup util
-///
-/// This macro optionally prints an informational message to stdout.
-/// The first parameter is a condition -- if it is true, nothing is done.
-/// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
-/// starting with a string. This is passed to printf() or an equivalent
-/// in order to format the informational message. For example,
-/// ADDR_INFO(0, ("test %d",3) ); prints out "test 3".
-///
-#define ADDR_INFO(cond, a)         \
-{ if (!(cond)) { ADDR_PRNT(a); } }
-
-
-/// @brief Macro for reporting error warning messages
-/// @ingroup util
-///
-/// This macro optionally prints an error warning message to stdout,
-/// followed by the file name and line number where the macro was called.
-/// The first parameter is a condition -- if it is true, nothing is done.
-/// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
-/// starting with a string. This is passed to printf() or an equivalent
-/// in order to format the informational message. For example,
-/// ADDR_WARN(0, ("test %d",3) ); prints out "test 3" followed by
-/// a second line with the file name and line number.
-///
-#define ADDR_WARN(cond, a)         \
-{ if (!(cond))                     \
-  { ADDR_PRNT(a);                  \
-    ADDR_PRNT(("  WARNING in file %s, line %d\n", __FILE__, __LINE__)); \
-} }
-
-
-/// @brief Macro for reporting fatal error conditions
-/// @ingroup util
-///
-/// This macro optionally stops execution of the current routine
-/// after printing an error warning message to stdout,
-/// followed by the file name and line number where the macro was called.
-/// The first parameter is a condition -- if it is true, nothing is done.
-/// The second pararmeter MUST be a parenthesis-enclosed list of arguments,
-/// starting with a string. This is passed to printf() or an equivalent
-/// in order to format the informational message. For example,
-/// ADDR_EXIT(0, ("test %d",3) ); prints out "test 3" followed by
-/// a second line with the file name and line number, then stops execution.
-///
-#define ADDR_EXIT(cond, a)         \
-{ if (!(cond))                     \
-  { ADDR_PRNT(a); ADDR_DBG_BREAK();\
-} }
-
-#else // DEBUG
-
-#define ADDRDPF 1 ? (void)0 : (void)
-
-#define ADDR_PRNT(a)
-
-#define ADDR_DBG_BREAK()
-
-#define ADDR_INFO(cond, a)
-
-#define ADDR_WARN(cond, a)
-
-#define ADDR_EXIT(cond, a)
-
-#endif // DEBUG
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#define ADDR_C_ASSERT(__e) typedef char __ADDR_C_ASSERT__[(__e) ? 1 : -1]
-
-namespace Addr
-{
-
-namespace V1
-{
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Common constants
-////////////////////////////////////////////////////////////////////////////////////////////////////
-static const UINT_32 MicroTileWidth      = 8;       ///< Micro tile width, for 1D and 2D tiling
-static const UINT_32 MicroTileHeight     = 8;       ///< Micro tile height, for 1D and 2D tiling
-static const UINT_32 ThickTileThickness  = 4;       ///< Micro tile thickness, for THICK modes
-static const UINT_32 XThickTileThickness = 8;       ///< Extra thick tiling thickness
-static const UINT_32 PowerSaveTileBytes  = 64;      ///< Nuber of bytes per tile for power save 64
-static const UINT_32 CmaskCacheBits      = 1024;    ///< Number of bits for CMASK cache
-static const UINT_32 CmaskElemBits       = 4;       ///< Number of bits for CMASK element
-static const UINT_32 HtileCacheBits      = 16384;   ///< Number of bits for HTILE cache 512*32
-
-static const UINT_32 MicroTilePixels     = MicroTileWidth * MicroTileHeight;
-
-static const INT_32 TileIndexInvalid        = TILEINDEX_INVALID;
-static const INT_32 TileIndexLinearGeneral  = TILEINDEX_LINEAR_GENERAL;
-static const INT_32 TileIndexNoMacroIndex   = -3;
-
-} // V1
-
-namespace V2
-{
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Common constants
-////////////////////////////////////////////////////////////////////////////////////////////////////
-static const UINT_32 MaxSurfaceHeight = 16384;
-
-} // V2
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Common macros
-////////////////////////////////////////////////////////////////////////////////////////////////////
-#define BITS_PER_BYTE 8
-#define BITS_TO_BYTES(x) ( ((x) + (BITS_PER_BYTE-1)) / BITS_PER_BYTE )
-#define BYTES_TO_BITS(x) ( (x) * BITS_PER_BYTE )
-
-/// Helper macros to select a single bit from an int (undefined later in section)
-#define _BIT(v,b)      (((v) >> (b) ) & 1)
-
-/**
-****************************************************************************************************
-* @brief Enums to identify AddrLib type
-****************************************************************************************************
-*/
-enum LibClass
-{
-    BASE_ADDRLIB = 0x0,
-    R600_ADDRLIB = 0x6,
-    R800_ADDRLIB = 0x8,
-    SI_ADDRLIB   = 0xa,
-    CI_ADDRLIB   = 0xb,
-    AI_ADDRLIB   = 0xd,
-};
-
-/**
-****************************************************************************************************
-* ChipFamily
-*
-*   @brief
-*       Neutral enums that specifies chip family.
-*
-****************************************************************************************************
-*/
-enum ChipFamily
-{
-    ADDR_CHIP_FAMILY_IVLD,    ///< Invalid family
-    ADDR_CHIP_FAMILY_R6XX,
-    ADDR_CHIP_FAMILY_R7XX,
-    ADDR_CHIP_FAMILY_R8XX,
-    ADDR_CHIP_FAMILY_NI,
-    ADDR_CHIP_FAMILY_SI,
-    ADDR_CHIP_FAMILY_CI,
-    ADDR_CHIP_FAMILY_VI,
-    ADDR_CHIP_FAMILY_AI,
-};
-
-/**
-****************************************************************************************************
-* ConfigFlags
-*
-*   @brief
-*       This structure is used to set configuration flags.
-****************************************************************************************************
-*/
-union ConfigFlags
-{
-    struct
-    {
-        /// These flags are set up internally thru AddrLib::Create() based on ADDR_CREATE_FLAGS
-        UINT_32 optimalBankSwap        : 1;    ///< New bank tiling for RV770 only
-        UINT_32 noCubeMipSlicesPad     : 1;    ///< Disables faces padding for cubemap mipmaps
-        UINT_32 fillSizeFields         : 1;    ///< If clients fill size fields in all input and
-                                               ///  output structure
-        UINT_32 ignoreTileInfo         : 1;    ///< Don't use tile info structure
-        UINT_32 useTileIndex           : 1;    ///< Make tileIndex field in input valid
-        UINT_32 useCombinedSwizzle     : 1;    ///< Use combined swizzle
-        UINT_32 checkLast2DLevel       : 1;    ///< Check the last 2D mip sub level
-        UINT_32 useHtileSliceAlign     : 1;    ///< Do htile single slice alignment
-        UINT_32 allowLargeThickTile    : 1;    ///< Allow 64*thickness*bytesPerPixel > rowSize
-        UINT_32 disableLinearOpt       : 1;    ///< Disallow tile modes to be optimized to linear
-        UINT_32 reserved               : 22;   ///< Reserved bits for future use
-    };
-
-    UINT_32 value;
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Misc helper functions
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
-****************************************************************************************************
-*   AddrXorReduce
-*
-*   @brief
-*       Xor the right-side numberOfBits bits of x.
-****************************************************************************************************
-*/
-static inline UINT_32 XorReduce(
-    UINT_32 x,
-    UINT_32 numberOfBits)
-{
-    UINT_32 i;
-    UINT_32 result = x & 1;
-
-    for (i=1; i<numberOfBits; i++)
-    {
-        result ^= ((x>>i) & 1);
-    }
-
-    return result;
-}
-
-/**
-****************************************************************************************************
-*   IsPow2
-*
-*   @brief
-*       Check if the size (UINT_32) is pow 2
-****************************************************************************************************
-*/
-static inline UINT_32 IsPow2(
-    UINT_32 dim)        ///< [in] dimension of miplevel
-{
-    ADDR_ASSERT(dim > 0);
-    return !(dim & (dim - 1));
-}
-
-/**
-****************************************************************************************************
-*   IsPow2
-*
-*   @brief
-*       Check if the size (UINT_64) is pow 2
-****************************************************************************************************
-*/
-static inline UINT_64 IsPow2(
-    UINT_64 dim)        ///< [in] dimension of miplevel
-{
-    ADDR_ASSERT(dim > 0);
-    return !(dim & (dim - 1));
-}
-
-/**
-****************************************************************************************************
-*   ByteAlign
-*
-*   @brief
-*       Align UINT_32 "x" to "align" alignment, "align" should be power of 2
-****************************************************************************************************
-*/
-static inline UINT_32 PowTwoAlign(
-    UINT_32 x,
-    UINT_32 align)
-{
-    //
-    // Assert that x is a power of two.
-    //
-    ADDR_ASSERT(IsPow2(align));
-    return (x + (align - 1)) & (~(align - 1));
-}
-
-/**
-****************************************************************************************************
-*   ByteAlign
-*
-*   @brief
-*       Align UINT_64 "x" to "align" alignment, "align" should be power of 2
-****************************************************************************************************
-*/
-static inline UINT_64 PowTwoAlign(
-    UINT_64 x,
-    UINT_64 align)
-{
-    //
-    // Assert that x is a power of two.
-    //
-    ADDR_ASSERT(IsPow2(align));
-    return (x + (align - 1)) & (~(align - 1));
-}
-
-/**
-****************************************************************************************************
-*   Min
-*
-*   @brief
-*       Get the min value between two unsigned values
-****************************************************************************************************
-*/
-static inline UINT_32 Min(
-    UINT_32 value1,
-    UINT_32 value2)
-{
-    return ((value1 < (value2)) ? (value1) : value2);
-}
-
-/**
-****************************************************************************************************
-*   Min
-*
-*   @brief
-*       Get the min value between two signed values
-****************************************************************************************************
-*/
-static inline INT_32 Min(
-    INT_32 value1,
-    INT_32 value2)
-{
-    return ((value1 < (value2)) ? (value1) : value2);
-}
-
-/**
-****************************************************************************************************
-*   Max
-*
-*   @brief
-*       Get the max value between two unsigned values
-****************************************************************************************************
-*/
-static inline UINT_32 Max(
-    UINT_32 value1,
-    UINT_32 value2)
-{
-    return ((value1 > (value2)) ? (value1) : value2);
-}
-
-/**
-****************************************************************************************************
-*   Max
-*
-*   @brief
-*       Get the max value between two signed values
-****************************************************************************************************
-*/
-static inline INT_32 Max(
-    INT_32 value1,
-    INT_32 value2)
-{
-    return ((value1 > (value2)) ? (value1) : value2);
-}
-
-/**
-****************************************************************************************************
-*   NextPow2
-*
-*   @brief
-*       Compute the mipmap's next level dim size
-****************************************************************************************************
-*/
-static inline UINT_32 NextPow2(
-    UINT_32 dim)        ///< [in] dimension of miplevel
-{
-    UINT_32 newDim = 1;
-
-    if (dim > 0x7fffffff)
-    {
-        ADDR_ASSERT_ALWAYS();
-        newDim = 0x80000000;
-    }
-    else
-    {
-        while (newDim < dim)
-        {
-            newDim <<= 1;
-        }
-    }
-
-    return newDim;
-}
-
-/**
-****************************************************************************************************
-*   Log2NonPow2
-*
-*   @brief
-*       Compute log of base 2 no matter the target is power of 2 or not
-****************************************************************************************************
-*/
-static inline UINT_32 Log2NonPow2(
-    UINT_32 x)      ///< [in] the value should calculate log based 2
-{
-    UINT_32 y;
-
-    y = 0;
-    while (x > 1)
-    {
-        x >>= 1;
-        y++;
-    }
-
-    return y;
-}
-
-/**
-****************************************************************************************************
-*   Log2
-*
-*   @brief
-*       Compute log of base 2
-****************************************************************************************************
-*/
-static inline UINT_32 Log2(
-    UINT_32 x)      ///< [in] the value should calculate log based 2
-{
-    // Assert that x is a power of two.
-    ADDR_ASSERT(IsPow2(x));
-
-    return Log2NonPow2(x);
-}
-
-/**
-****************************************************************************************************
-*   QLog2
-*
-*   @brief
-*       Compute log of base 2 quickly (<= 16)
-****************************************************************************************************
-*/
-static inline UINT_32 QLog2(
-    UINT_32 x)      ///< [in] the value should calculate log based 2
-{
-    ADDR_ASSERT(x <= 16);
-
-    UINT_32 y = 0;
-
-    switch (x)
-    {
-        case 1:
-            y = 0;
-            break;
-        case 2:
-            y = 1;
-            break;
-        case 4:
-            y = 2;
-            break;
-        case 8:
-            y = 3;
-            break;
-        case 16:
-            y = 4;
-            break;
-        default:
-            ADDR_ASSERT_ALWAYS();
-    }
-
-    return y;
-}
-
-/**
-****************************************************************************************************
-*   SafeAssign
-*
-*   @brief
-*       NULL pointer safe assignment
-****************************************************************************************************
-*/
-static inline VOID SafeAssign(
-    UINT_32*    pLVal,  ///< [in] Pointer to left val
-    UINT_32     rVal)   ///< [in] Right value
-{
-    if (pLVal)
-    {
-        *pLVal = rVal;
-    }
-}
-
-/**
-****************************************************************************************************
-*   SafeAssign
-*
-*   @brief
-*       NULL pointer safe assignment for 64bit values
-****************************************************************************************************
-*/
-static inline VOID SafeAssign(
-    UINT_64*    pLVal,  ///< [in] Pointer to left val
-    UINT_64     rVal)   ///< [in] Right value
-{
-    if (pLVal)
-    {
-        *pLVal = rVal;
-    }
-}
-
-/**
-****************************************************************************************************
-*   SafeAssign
-*
-*   @brief
-*       NULL pointer safe assignment for AddrTileMode
-****************************************************************************************************
-*/
-static inline VOID SafeAssign(
-    AddrTileMode*    pLVal, ///< [in] Pointer to left val
-    AddrTileMode     rVal)  ///< [in] Right value
-{
-    if (pLVal)
-    {
-        *pLVal = rVal;
-    }
-}
-
-/**
-****************************************************************************************************
-*   RoundHalf
-*
-*   @brief
-*       return (x + 1) / 2
-****************************************************************************************************
-*/
-static inline UINT_32 RoundHalf(
-    UINT_32     x)     ///< [in] input value
-{
-    ADDR_ASSERT(x != 0);
-
-#if 1
-    return (x >> 1) + (x & 1);
-#else
-    return (x + 1) >> 1;
-#endif
-}
-
-/**
-****************************************************************************************************
-*   SumGeo
-*
-*   @brief
-*       Calculate sum of a geometric progression whose ratio is 1/2
-****************************************************************************************************
-*/
-static inline UINT_32 SumGeo(
-    UINT_32     base,   ///< [in] First term in the geometric progression
-    UINT_32     num)    ///< [in] Number of terms to be added into sum
-{
-    ADDR_ASSERT(base > 0);
-
-    UINT_32 sum = 0;
-    UINT_32 i = 0;
-    for (; (i < num) && (base > 1); i++)
-    {
-        sum += base;
-        base = RoundHalf(base);
-    }
-    sum += num - i;
-
-    return sum;
-}
-
-/**
-****************************************************************************************************
-*   GetBit
-*
-*   @brief
-*       Extract bit N value (0 or 1) of a UINT32 value.
-****************************************************************************************************
-*/
-static inline UINT_32 GetBit(
-    UINT_32     u32,   ///< [in] UINT32 value
-    UINT_32     pos)   ///< [in] bit position from LSB, valid range is [0..31]
-{
-    ADDR_ASSERT(pos <= 31);
-
-    return (u32 >> pos) & 0x1;
-}
-
-/**
-****************************************************************************************************
-*   GetBits
-*
-*   @brief
-*       Copy 'bitsNum' bits from src start from srcStartPos into destination from dstStartPos
-*       srcStartPos: 0~31 for UINT_32
-*       bitsNum    : 1~32 for UINT_32
-*       srcStartPos: 0~31 for UINT_32
-*                                                                 src start position
-*                                                                          |
-*       src : b[31] b[30] b[29] ... ... ... ... ... ... ... ... b[end]..b[beg] ... b[1] b[0]
-*                                   || Bits num || copy length  || Bits num ||
-*       dst : b[31] b[30] b[29] ... b[end]..b[beg] ... ... ... ... ... ... ... ... b[1] b[0]
-*                                              |
-*                                     dst start position
-****************************************************************************************************
-*/
-static inline UINT_32 GetBits(
-    UINT_32 src,
-    UINT_32 srcStartPos,
-    UINT_32 bitsNum,
-    UINT_32 dstStartPos)
-{
-    ADDR_ASSERT((srcStartPos < 32) && (dstStartPos < 32) && (bitsNum > 0));
-    ADDR_ASSERT((bitsNum + dstStartPos <= 32) && (bitsNum + srcStartPos <= 32));
-
-    return ((src >> srcStartPos) << (32 - bitsNum)) >> (32 - bitsNum - dstStartPos);
-}
-
-/**
-****************************************************************************************************
-*   MortonGen2d
-*
-*   @brief
-*       Generate 2D Morton interleave code with num lowest bits in each channel
-****************************************************************************************************
-*/
-static inline UINT_32 MortonGen2d(
-    UINT_32     x,     ///< [in] First channel
-    UINT_32     y,     ///< [in] Second channel
-    UINT_32     num)   ///< [in] Number of bits extracted from each channel
-{
-    UINT_32 mort = 0;
-
-    for (UINT_32 i = 0; i < num; i++)
-    {
-        mort |= (GetBit(y, i) << (2 * i));
-        mort |= (GetBit(x, i) << (2 * i + 1));
-    }
-
-    return mort;
-}
-
-/**
-****************************************************************************************************
-*   MortonGen3d
-*
-*   @brief
-*       Generate 3D Morton interleave code with num lowest bits in each channel
-****************************************************************************************************
-*/
-static inline UINT_32 MortonGen3d(
-    UINT_32     x,     ///< [in] First channel
-    UINT_32     y,     ///< [in] Second channel
-    UINT_32     z,     ///< [in] Third channel
-    UINT_32     num)   ///< [in] Number of bits extracted from each channel
-{
-    UINT_32 mort = 0;
-
-    for (UINT_32 i = 0; i < num; i++)
-    {
-        mort |= (GetBit(z, i) << (3 * i));
-        mort |= (GetBit(y, i) << (3 * i + 1));
-        mort |= (GetBit(x, i) << (3 * i + 2));
-    }
-
-    return mort;
-}
-
-/**
-****************************************************************************************************
-*   ReverseBitVector
-*
-*   @brief
-*       Return reversed lowest num bits of v: v[0]v[1]...v[num-2]v[num-1]
-****************************************************************************************************
-*/
-static inline UINT_32 ReverseBitVector(
-    UINT_32     v,     ///< [in] Reverse operation base value
-    UINT_32     num)   ///< [in] Number of bits used in reverse operation
-{
-    UINT_32 reverse = 0;
-
-    for (UINT_32 i = 0; i < num; i++)
-    {
-        reverse |= (GetBit(v, num - 1 - i) << i);
-    }
-
-    return reverse;
-}
-
-/**
-****************************************************************************************************
-*   FoldXor2d
-*
-*   @brief
-*       Xor bit vector v[num-1]v[num-2]...v[1]v[0] with v[num]v[num+1]...v[2*num-2]v[2*num-1]
-****************************************************************************************************
-*/
-static inline UINT_32 FoldXor2d(
-    UINT_32     v,     ///< [in] Xor operation base value
-    UINT_32     num)   ///< [in] Number of bits used in fold xor operation
-{
-    return (v & ((1 << num) - 1)) ^ ReverseBitVector(v >> num, num);
-}
-
-/**
-****************************************************************************************************
-*   DeMort
-*
-*   @brief
-*       Return v[0] | v[2] | v[4] | v[6]... | v[2*num - 2]
-****************************************************************************************************
-*/
-static inline UINT_32 DeMort(
-    UINT_32     v,     ///< [in] DeMort operation base value
-    UINT_32     num)   ///< [in] Number of bits used in fold DeMort operation
-{
-    UINT_32 d = 0;
-
-    for (UINT_32 i = 0; i < num; i++)
-    {
-        d |= ((v & (1 << (i << 1))) >> i);
-    }
-
-    return d;
-}
-
-/**
-****************************************************************************************************
-*   FoldXor3d
-*
-*   @brief
-*       v[0]...v[num-1] ^ v[3*num-1]v[3*num-3]...v[num+2]v[num] ^ v[3*num-2]...v[num+1]v[num-1]
-****************************************************************************************************
-*/
-static inline UINT_32 FoldXor3d(
-    UINT_32     v,     ///< [in] Xor operation base value
-    UINT_32     num)   ///< [in] Number of bits used in fold xor operation
-{
-    UINT_32 t = v & ((1 << num) - 1);
-    t ^= ReverseBitVector(DeMort(v >> num, num), num);
-    t ^= ReverseBitVector(DeMort(v >> (num + 1), num), num);
-
-    return t;
-}
-
-/**
-****************************************************************************************************
-*   InitChannel
-*
-*   @brief
-*       Set channel initialization value via a return value
-****************************************************************************************************
-*/
-static inline ADDR_CHANNEL_SETTING InitChannel(
-    UINT_32     valid,     ///< [in] valid setting
-    UINT_32     channel,   ///< [in] channel setting
-    UINT_32     index)     ///< [in] index setting
-{
-    ADDR_CHANNEL_SETTING t;
-    t.valid = valid;
-    t.channel = channel;
-    t.index = index;
-
-    return t;
-}
-
-/**
-****************************************************************************************************
-*   InitChannel
-*
-*   @brief
-*       Set channel initialization value via channel pointer
-****************************************************************************************************
-*/
-static inline VOID InitChannel(
-    UINT_32     valid,              ///< [in] valid setting
-    UINT_32     channel,            ///< [in] channel setting
-    UINT_32     index,              ///< [in] index setting
-    ADDR_CHANNEL_SETTING *pChanSet) ///< [out] channel setting to be initialized
-{
-    pChanSet->valid = valid;
-    pChanSet->channel = channel;
-    pChanSet->index = index;
-}
-
-
-/**
-****************************************************************************************************
-*   InitChannel
-*
-*   @brief
-*       Set channel initialization value via another channel
-****************************************************************************************************
-*/
-static inline VOID InitChannel(
-    ADDR_CHANNEL_SETTING *pChanDst, ///< [in] channel setting to be copied from
-    ADDR_CHANNEL_SETTING *pChanSrc) ///< [out] channel setting to be initialized
-{
-    pChanDst->valid = pChanSrc->valid;
-    pChanDst->channel = pChanSrc->channel;
-    pChanDst->index = pChanSrc->index;
-}
-
-/**
-****************************************************************************************************
-*   GetMaxValidChannelIndex
-*
-*   @brief
-*       Get max valid index for a specific channel
-****************************************************************************************************
-*/
-static inline UINT_32 GetMaxValidChannelIndex(
-    const ADDR_CHANNEL_SETTING *pChanSet,   ///< [in] channel setting to be initialized
-    UINT_32                     searchCount,///< [in] number of channel setting to be searched
-    UINT_32                     channel)    ///< [in] channel to be searched
-{
-    UINT_32 index = 0;
-
-    for (UINT_32 i = 0; i < searchCount; i++)
-    {
-        if (pChanSet[i].valid && (pChanSet[i].channel == channel))
-        {
-            index = Max(index, static_cast<UINT_32>(pChanSet[i].index));
-        }
-    }
-
-    return index;
-}
-
-/**
-****************************************************************************************************
-*   GetCoordActiveMask
-*
-*   @brief
-*       Get bit mask which indicates which positions in the equation match the target coord
-****************************************************************************************************
-*/
-static inline UINT_32 GetCoordActiveMask(
-    const ADDR_CHANNEL_SETTING *pChanSet,   ///< [in] channel setting to be initialized
-    UINT_32                     searchCount,///< [in] number of channel setting to be searched
-    UINT_32                     channel,    ///< [in] channel to be searched
-    UINT_32                     index)      ///< [in] index to be searched
-{
-    UINT_32 mask = 0;
-
-    for (UINT_32 i = 0; i < searchCount; i++)
-    {
-        if ((pChanSet[i].valid   == TRUE)    &&
-            (pChanSet[i].channel == channel) &&
-            (pChanSet[i].index   == index))
-        {
-            mask |= (1 << i);
-        }
-    }
-
-    return mask;
-}
-
-} // Addr
-
-#endif // __ADDR_COMMON_H__
-
diff --git a/src/amd/addrlib/core/addrelemlib.cpp b/src/amd/addrlib/core/addrelemlib.cpp
deleted file mode 100644 (file)
index c9e6da4..0000000
+++ /dev/null
@@ -1,1843 +0,0 @@
-/*
- * 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  addrelemlib.cpp
-* @brief Contains the class implementation for element/pixel related functions.
-****************************************************************************************************
-*/
-
-#include "addrelemlib.h"
-#include "addrlib.h"
-
-namespace Addr
-{
-
-/**
-****************************************************************************************************
-*   ElemLib::ElemLib
-*
-*   @brief
-*       constructor
-*
-*   @return
-*       N/A
-****************************************************************************************************
-*/
-ElemLib::ElemLib(
-    Lib* pAddrLib)  ///< [in] Parent addrlib instance pointer
-    :
-    Object(pAddrLib->GetClient()),
-    m_pAddrLib(pAddrLib)
-{
-    switch (m_pAddrLib->GetChipFamily())
-    {
-        case ADDR_CHIP_FAMILY_R6XX:
-            m_depthPlanarType = ADDR_DEPTH_PLANAR_R600;
-            m_fp16ExportNorm = 0;
-            break;
-        case ADDR_CHIP_FAMILY_R7XX:
-            m_depthPlanarType = ADDR_DEPTH_PLANAR_R600;
-            m_fp16ExportNorm = 1;
-            break;
-        case ADDR_CHIP_FAMILY_R8XX:
-        case ADDR_CHIP_FAMILY_NI: // Same as 8xx
-            m_depthPlanarType = ADDR_DEPTH_PLANAR_R800;
-            m_fp16ExportNorm = 1;
-            break;
-        default:
-            m_fp16ExportNorm = 1;
-            m_depthPlanarType = ADDR_DEPTH_PLANAR_R800;
-    }
-
-    m_configFlags.value = 0;
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::~ElemLib
-*
-*   @brief
-*       destructor
-*
-*   @return
-*       N/A
-****************************************************************************************************
-*/
-ElemLib::~ElemLib()
-{
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::Create
-*
-*   @brief
-*       Creates and initializes AddrLib object.
-*
-*   @return
-*       Returns point to ADDR_CREATEINFO if successful.
-****************************************************************************************************
-*/
-ElemLib* ElemLib::Create(
-    const Lib* pAddrLib)   ///< [in] Pointer of parent AddrLib instance
-{
-    ElemLib* pElemLib = NULL;
-
-    if (pAddrLib)
-    {
-        VOID* pObj = Object::ClientAlloc(sizeof(ElemLib), pAddrLib->GetClient());
-        if (pObj)
-        {
-            pElemLib = new(pObj) ElemLib(const_cast<Lib* const>(pAddrLib));
-        }
-    }
-
-    return pElemLib;
-}
-
-/**************************************************************************************************
-*   ElemLib::Flt32sToInt32s
-*
-*   @brief
-*       Convert a ADDR_FLT_32 value to Int32 value
-*
-*   @return
-*       N/A
-****************************************************************************************************
-*/
-VOID ElemLib::Flt32sToInt32s(
-    ADDR_FLT_32     value,      ///< [in] ADDR_FLT_32 value
-    UINT_32         bits,       ///< [in] nubmer of bits in value
-    NumberType      numberType, ///< [in] the type of number
-    UINT_32*        pResult)    ///< [out] Int32 value
-{
-    UINT_8 round = 128;    //ADDR_ROUND_BY_HALF
-    UINT_32 uscale;
-    UINT_32 sign;
-
-    //convert each component to an INT_32
-    switch ( numberType )
-    {
-        case ADDR_NO_NUMBER:    //fall through
-        case ADDR_ZERO:         //fall through
-        case ADDR_ONE:          //fall through
-        case ADDR_EPSILON:      //fall through
-            return;        // these are zero-bit components, so don't set result
-
-        case ADDR_UINT_BITS:            // unsigned integer bit field, clamped to range
-            uscale = (1<<bits) - 1;
-            if (bits == 32)               // special case unsigned 32-bit int
-            {
-                *pResult = value.i;
-            }
-            else
-            {
-                if ((value.i < 0) || (value.u > uscale))
-                {
-                    *pResult = uscale;
-                }
-                else
-                {
-                    *pResult = value.i;
-                }
-                return;
-            }
-
-        // The algorithm used in the DB and TX differs at one value for 24-bit unorms
-        case ADDR_UNORM_R6XXDB:        // unsigned repeating fraction
-            if ((bits==24) && (value.i == 0x33000000))
-            {
-                *pResult = 1;
-                return;
-            }              // Else treat like ADDR_UNORM_R6XX
-
-        case ADDR_UNORM_R6XX:            // unsigned repeating fraction
-            if (value.f <= 0)
-            {
-                *pResult = 0;            // first clamp to [0..1]
-            }
-            else
-            {
-                if (value.f >= 1)
-                {
-                     *pResult = (1<<bits) - 1;
-                }
-                else
-                {
-                    if ((value.i | 0x87FFFFFF) == 0xFFFFFFFF)
-                    {
-                        *pResult = 0;                        // NaN, so force to 0
-                    }
-
-                    #if 0 // floating point version for documentation
-                    else
-                    {
-                        FLOAT f = value.f * ((1<<bits) - 1);
-                        *pResult = static_cast<INT_32>(f + (round/256.0f));
-                    }
-                    #endif
-                    else
-                    {
-                        ADDR_FLT_32 scaled;
-                        ADDR_FLT_32 shifted;
-                        UINT_64 truncated, rounded;
-                        UINT_32 altShift;
-                        UINT_32 mask = (1 << bits) - 1;
-                        UINT_32 half = 1 << (bits - 1);
-                        UINT_32 mant24 = (value.i & 0x7FFFFF) + 0x800000;
-                        UINT_64 temp = mant24 - (mant24>>bits) -
-                            static_cast<INT_32>((mant24 & mask) > half);
-                        UINT_32 exp8 = value.i >> 23;
-                        UINT_32 shift = 126 - exp8 + 24 - bits;
-                        UINT_64 final;
-
-                        if (shift >= 32) // This is zero, even with maximum dither add
-                        {
-                            final = 0;
-                        }
-                        else
-                        {
-                            final = ((temp<<8) + (static_cast<UINT_64>(round)<<shift)) >> (shift+8);
-                        }
-                        //ADDR_EXIT( *pResult == final,
-                        //    ("Float %x converted to %d-bit Unorm %x != bitwise %x",
-                        //     value.u, bits, (UINT_32)*pResult, (UINT_32)final) );
-                        if (final > mask)
-                        {
-                            final = mask;
-                        }
-
-                        scaled.f  = value.f * ((1<<bits) - 1);
-                        shifted.f = (scaled.f * 256);
-                        truncated = ((shifted.i&0x7FFFFF) + (INT_64)0x800000) << 8;
-                        altShift  = 126 + 24 + 8 - ((shifted.i>>23)&0xFF);
-                        truncated = (altShift > 60) ? 0 : truncated >> altShift;
-                        rounded   = static_cast<INT_32>((round + truncated) >> 8);
-                        //if (rounded > ((1<<bits) - 1))
-                        //    rounded = ((1<<bits) - 1);
-                        *pResult = static_cast<INT_32>(rounded); //(INT_32)final;
-                    }
-                }
-            }
-
-            return;
-
-        case ADDR_S8FLOAT32:    // 32-bit IEEE float, passes through NaN values
-            *pResult = value.i;
-            return;
-
-        // @@ FIX ROUNDING in this code, fix the denorm case
-        case ADDR_U4FLOATC:         // Unsigned float, 4-bit exponent. bias 15, clamped [0..1]
-            sign = (value.i >> 31) & 1;
-            if ((value.i&0x7F800000) == 0x7F800000)    // If NaN or INF:
-            {
-                if ((value.i&0x007FFFFF) != 0)             // then if NaN
-                {
-                    *pResult = 0;                       // return 0
-                }
-                else
-                {
-                    *pResult = (sign)?0:0xF00000;           // else +INF->+1, -INF->0
-                }
-                return;
-            }
-            if (value.f <= 0)
-            {
-                *pResult = 0;
-            }
-            else
-            {
-                if (value.f>=1)
-                {
-                    *pResult = 0xF << (bits-4);
-                }
-                else
-                {
-                    if ((value.i>>23) > 112 )
-                    {
-                        // 24-bit float: normalized
-                        // value.i += 1 << (22-bits+4);
-                        // round the IEEE mantissa to mantissa size
-                        // @@ NOTE: add code to support rounding
-                        value.u &= 0x7FFFFFF;             // mask off high 4 exponent bits
-                        *pResult = value.i >> (23-bits+4);// shift off unused mantissa bits
-                    }
-                    else
-                    {
-                        // 24-bit float: denormalized
-                        value.f = value.f / (1<<28) / (1<<28);
-                        value.f = value.f / (1<<28) / (1<<28);    // convert to IEEE denorm
-                        // value.i += 1 << (22-bits+4);
-                        // round the IEEE mantissa to mantissa size
-                        // @@ NOTE: add code to support rounding
-                        *pResult = value.i >> (23-bits+4);    // shift off unused mantissa bits
-                    }
-                }
-            }
-
-            return;
-
-        default:                    // invalid number mode
-            //ADDR_EXIT(0, ("Invalid AddrNumber %d", numberType) );
-            break;
-
-    }
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::Int32sToPixel
-*
-*   @brief
-*       Pack 32-bit integer values into an uncompressed pixel,
-*       in the proper order
-*
-*   @return
-*       N/A
-*
-*   @note
-*       This entry point packes four 32-bit integer values into
-*       an uncompressed pixel. The pixel values are specifies in
-*       standard order, e.g. depth/stencil. This routine asserts
-*       if called on compressed pixel.
-****************************************************************************************************
-*/
-VOID ElemLib::Int32sToPixel(
-    UINT_32              numComps,      ///< [in] number of components
-    UINT_32*             pComps,        ///< [in] compnents
-    UINT_32*             pCompBits,     ///< [in] total bits in each component
-    UINT_32*             pCompStart,    ///< [in] the first bit position of each component
-    ComponentFlags       properties,    ///< [in] properties about byteAligned, exportNorm
-    UINT_32              resultBits,    ///< [in] result bits: total bpp after decompression
-    UINT_8*              pPixel)        ///< [out] a depth/stencil pixel value
-{
-    UINT_32 i;
-    UINT_32 j;
-    UINT_32 start;
-    UINT_32 size;
-    UINT_32 byte;
-    UINT_32 value = 0;
-    UINT_32 compMask;
-    UINT_32 elemMask=0;
-    UINT_32 elementXor = 0;  // address xor when reading bytes from elements
-
-
-    // @@ NOTE: assert if called on a compressed format!
-
-    if (properties.byteAligned)    // Components are all byte-sized
-    {
-        for (i = 0; i < numComps; i++)        // Then for each component
-        {
-            // Copy the bytes of the component into the element
-            start = pCompStart[i] / 8;
-            size  = pCompBits[i]  / 8;
-            for (j = 0; j < size; j++)
-            {
-                pPixel[(j+start)^elementXor] = static_cast<UINT_8>(pComps[i] >> (8*j));
-            }
-        }
-    }
-    else                        // Element is 32-bits or less, components are bit fields
-    {
-        // First, extract each component in turn and combine it into a 32-bit value
-        for (i = 0; i < numComps; i++)
-        {
-            compMask = (1 << pCompBits[i]) - 1;
-            elemMask |= compMask << pCompStart[i];
-            value |= (pComps[i] & compMask) << pCompStart[i];
-        }
-
-        // Mext, copy the masked value into the element
-        size = (resultBits + 7) / 8;
-        for (i = 0; i < size; i++)
-        {
-            byte = pPixel[i^elementXor] & ~(elemMask >> (8*i));
-            pPixel[i^elementXor] = static_cast<UINT_8>(byte | ((elemMask & value) >> (8*i)));
-        }
-    }
-}
-
-/**
-****************************************************************************************************
-*   Flt32ToDepthPixel
-*
-*   @brief
-*       Convert a FLT_32 value to a depth/stencil pixel value
-*
-*   @return
-*       N/A
-****************************************************************************************************
-*/
-VOID ElemLib::Flt32ToDepthPixel(
-    AddrDepthFormat     format,     ///< [in] Depth format
-    const ADDR_FLT_32   comps[2],   ///< [in] two components of depth
-    UINT_8*             pPixel      ///< [out] depth pixel value
-    ) const
-{
-    UINT_32 i;
-    UINT_32 values[2];
-    ComponentFlags properties;  // byteAligned, exportNorm
-    UINT_32 resultBits = 0;     // result bits: total bits per pixel after decompression
-
-    PixelFormatInfo fmt;
-
-    // get type for each component
-    PixGetDepthCompInfo(format, &fmt);
-
-    //initialize properties
-    properties.byteAligned = TRUE;
-    properties.exportNorm  = TRUE;
-    properties.floatComp   = FALSE;
-
-    //set properties and result bits
-    for (i = 0; i < 2; i++)
-    {
-        if ((fmt.compBit[i] & 7) || (fmt.compStart[i] & 7))
-        {
-            properties.byteAligned = FALSE;
-        }
-
-        if (resultBits < fmt.compStart[i] + fmt.compBit[i])
-        {
-            resultBits = fmt.compStart[i] + fmt.compBit[i];
-        }
-
-        // Clear ADDR_EXPORT_NORM if can't be represented as 11-bit or smaller [-1..+1] format
-        if (fmt.compBit[i] > 11 || fmt.numType[i] >= ADDR_USCALED)
-        {
-            properties.exportNorm = FALSE;
-        }
-
-        // Mark if there are any floating point components
-        if ((fmt.numType[i] == ADDR_U4FLOATC) || (fmt.numType[i] >= ADDR_S8FLOAT) )
-        {
-            properties.floatComp = TRUE;
-        }
-    }
-
-    // Convert the two input floats to integer values
-    for (i = 0; i < 2; i++)
-    {
-        Flt32sToInt32s(comps[i], fmt.compBit[i], fmt.numType[i], &values[i]);
-    }
-
-    // Then pack the two integer components, in the proper order
-    Int32sToPixel(2, values, fmt.compBit, fmt.compStart, properties, resultBits, pPixel );
-
-}
-
-/**
-****************************************************************************************************
-*   Flt32ToColorPixel
-*
-*   @brief
-*       Convert a FLT_32 value to a red/green/blue/alpha pixel value
-*
-*   @return
-*       N/A
-****************************************************************************************************
-*/
-VOID ElemLib::Flt32ToColorPixel(
-    AddrColorFormat     format,     ///< [in] Color format
-    AddrSurfaceNumber   surfNum,    ///< [in] Surface number
-    AddrSurfaceSwap     surfSwap,   ///< [in] Surface swap
-    const ADDR_FLT_32   comps[4],   ///< [in] four components of color
-    UINT_8*             pPixel      ///< [out] a red/green/blue/alpha pixel value
-    ) const
-{
-    PixelFormatInfo pixelInfo;
-
-    UINT_32 i;
-    UINT_32 values[4];
-    ComponentFlags properties;    // byteAligned, exportNorm
-    UINT_32 resultBits = 0;       // result bits: total bits per pixel after decompression
-
-    memset(&pixelInfo, 0, sizeof(PixelFormatInfo));
-
-    PixGetColorCompInfo(format, surfNum, surfSwap, &pixelInfo);
-
-    //initialize properties
-    properties.byteAligned = TRUE;
-    properties.exportNorm  = TRUE;
-    properties.floatComp   = FALSE;
-
-    //set properties and result bits
-    for (i = 0; i < 4; i++)
-    {
-        if ( (pixelInfo.compBit[i] & 7) || (pixelInfo.compStart[i] & 7) )
-        {
-            properties.byteAligned = FALSE;
-        }
-
-        if (resultBits < pixelInfo.compStart[i] + pixelInfo.compBit[i])
-        {
-            resultBits = pixelInfo.compStart[i] + pixelInfo.compBit[i];
-        }
-
-        if (m_fp16ExportNorm)
-        {
-            // Clear ADDR_EXPORT_NORM if can't be represented as 11-bit or smaller [-1..+1] format
-            // or if it's not FP and <=16 bits
-            if (((pixelInfo.compBit[i] > 11) || (pixelInfo.numType[i] >= ADDR_USCALED))
-                && (pixelInfo.numType[i] !=ADDR_U4FLOATC))
-            {
-                properties.exportNorm = FALSE;
-            }
-        }
-        else
-        {
-            // Clear ADDR_EXPORT_NORM if can't be represented as 11-bit or smaller [-1..+1] format
-            if (pixelInfo.compBit[i] > 11 || pixelInfo.numType[i] >= ADDR_USCALED)
-            {
-                properties.exportNorm = FALSE;
-            }
-        }
-
-        // Mark if there are any floating point components
-        if ( (pixelInfo.numType[i] == ADDR_U4FLOATC) ||
-             (pixelInfo.numType[i] >= ADDR_S8FLOAT) )
-        {
-            properties.floatComp = TRUE;
-        }
-    }
-
-    // Convert the four input floats to integer values
-    for (i = 0; i < 4; i++)
-    {
-        Flt32sToInt32s(comps[i], pixelInfo.compBit[i], pixelInfo.numType[i], &values[i]);
-    }
-
-    // Then pack the four integer components, in the proper order
-    Int32sToPixel(4, values, &pixelInfo.compBit[0], &pixelInfo.compStart[0],
-                  properties, resultBits, pPixel);
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::GetCompType
-*
-*   @brief
-*       Fill per component info
-*
-*   @return
-*       N/A
-*
-****************************************************************************************************
-*/
-VOID ElemLib::GetCompType(
-    AddrColorFormat   format,     ///< [in] surface format
-    AddrSurfaceNumber numType,  ///< [in] number type
-    PixelFormatInfo*  pInfo)       ///< [in][out] per component info out
-{
-    BOOL_32 handled = FALSE;
-
-    // Floating point formats override the number format
-    switch (format)
-    {
-        case ADDR_COLOR_16_FLOAT:            // fall through for all pure floating point format
-        case ADDR_COLOR_16_16_FLOAT:
-        case ADDR_COLOR_16_16_16_16_FLOAT:
-        case ADDR_COLOR_32_FLOAT:
-        case ADDR_COLOR_32_32_FLOAT:
-        case ADDR_COLOR_32_32_32_32_FLOAT:
-        case ADDR_COLOR_10_11_11_FLOAT:
-        case ADDR_COLOR_11_11_10_FLOAT:
-            numType = ADDR_NUMBER_FLOAT;
-            break;
-            // Special handling for the depth formats
-        case ADDR_COLOR_8_24:                // fall through for these 2 similar format
-        case ADDR_COLOR_24_8:
-            for (UINT_32 c = 0; c < 4; c++)
-            {
-                if (pInfo->compBit[c] == 8)
-                {
-                    pInfo->numType[c] = ADDR_UINT_BITS;
-                }
-                else if (pInfo->compBit[c]  == 24)
-                {
-                    pInfo->numType[c] = ADDR_UNORM_R6XX;
-                }
-                else
-                {
-                    pInfo->numType[c] = ADDR_NO_NUMBER;
-                }
-            }
-            handled = TRUE;
-            break;
-        case ADDR_COLOR_8_24_FLOAT:          // fall through for these 3 similar format
-        case ADDR_COLOR_24_8_FLOAT:
-        case ADDR_COLOR_X24_8_32_FLOAT:
-            for (UINT_32 c = 0; c < 4; c++)
-            {
-                if (pInfo->compBit[c] == 8)
-                {
-                    pInfo->numType[c] = ADDR_UINT_BITS;
-                }
-                else if (pInfo->compBit[c] == 24)
-                {
-                    pInfo->numType[c] = ADDR_U4FLOATC;
-                }
-                else if (pInfo->compBit[c] == 32)
-                {
-                    pInfo->numType[c] = ADDR_S8FLOAT32;
-                }
-                else
-                {
-                    pInfo->numType[c] = ADDR_NO_NUMBER;
-                }
-            }
-            handled = TRUE;
-            break;
-        default:
-            break;
-    }
-
-    if (!handled)
-    {
-        for (UINT_32 c = 0; c < 4; c++)
-        {
-            // Assign a number type for each component
-            AddrSurfaceNumber cnum;
-
-            // First handle default component values
-            if (pInfo->compBit[c] == 0)
-            {
-                if (c < 3)
-                {
-                    pInfo->numType[c] = ADDR_ZERO;      // Default is zero for RGB
-                }
-                else if (numType == ADDR_NUMBER_UINT || numType == ADDR_NUMBER_SINT)
-                {
-                    pInfo->numType[c] = ADDR_EPSILON;   // Alpha INT_32 bits default is 0x01
-                }
-                else
-                {
-                    pInfo->numType[c] = ADDR_ONE;       // Alpha normal default is float 1.0
-                }
-                continue;
-            }
-            // Now handle small components
-            else if (pInfo->compBit[c] == 1)
-            {
-                if (numType == ADDR_NUMBER_UINT || numType == ADDR_NUMBER_SINT)
-                {
-                    cnum = ADDR_NUMBER_UINT;
-                }
-                else
-                {
-                    cnum = ADDR_NUMBER_UNORM;
-                }
-            }
-            else
-            {
-                cnum = numType;
-            }
-
-            // If no default, set the number type fom num, compbits, and architecture
-            switch (cnum)
-            {
-                case ADDR_NUMBER_SRGB:
-                    pInfo->numType[c] = (c < 3) ? ADDR_GAMMA8_R6XX : ADDR_UNORM_R6XX;
-                    break;
-                case ADDR_NUMBER_UNORM:
-                    pInfo->numType[c] = ADDR_UNORM_R6XX;
-                    break;
-                case ADDR_NUMBER_SNORM:
-                    pInfo->numType[c] = ADDR_SNORM_R6XX;
-                    break;
-                case ADDR_NUMBER_USCALED:
-                    pInfo->numType[c] = ADDR_USCALED;  // @@ Do we need separate Pele routine?
-                    break;
-                case ADDR_NUMBER_SSCALED:
-                    pInfo->numType[c] = ADDR_SSCALED;  // @@ Do we need separate Pele routine?
-                    break;
-                case ADDR_NUMBER_FLOAT:
-                    if (pInfo->compBit[c] == 32)
-                    {
-                        pInfo->numType[c] = ADDR_S8FLOAT32;
-                    }
-                    else if (pInfo->compBit[c] == 16)
-                    {
-                        pInfo->numType[c] = ADDR_S5FLOAT;
-                    }
-                    else if (pInfo->compBit[c] >= 10)
-                    {
-                        pInfo->numType[c] = ADDR_U5FLOAT;
-                    }
-                    else
-                    {
-                        ADDR_ASSERT_ALWAYS();
-                    }
-                    break;
-                case ADDR_NUMBER_SINT:
-                    pInfo->numType[c] = ADDR_SINT_BITS;
-                    break;
-                case ADDR_NUMBER_UINT:
-                    pInfo->numType[c] = ADDR_UINT_BITS;
-                    break;
-
-                default:
-                    ADDR_ASSERT(!"Invalid number type");
-                    pInfo->numType[c] = ADDR_NO_NUMBER;
-                    break;
-             }
-        }
-    }
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::GetCompSwap
-*
-*   @brief
-*       Get components swapped for color surface
-*
-*   @return
-*       N/A
-*
-****************************************************************************************************
-*/
-VOID ElemLib::GetCompSwap(
-    AddrSurfaceSwap  swap,   ///< [in] swap mode
-    PixelFormatInfo* pInfo)  ///< [in,out] output per component info
-{
-    switch (pInfo->comps)
-    {
-        case 4:
-            switch (swap)
-            {
-                case ADDR_SWAP_ALT:
-                    SwapComps( 0, 2, pInfo );
-                    break;    // BGRA
-                case ADDR_SWAP_STD_REV:
-                    SwapComps( 0, 3, pInfo );
-                    SwapComps( 1, 2, pInfo );
-                    break;    // ABGR
-                case ADDR_SWAP_ALT_REV:
-                    SwapComps( 0, 3, pInfo );
-                    SwapComps( 0, 2, pInfo );
-                    SwapComps( 0, 1, pInfo );
-                    break;    // ARGB
-                default:
-                    break;
-            }
-            break;
-        case 3:
-            switch (swap)
-            {
-                case ADDR_SWAP_ALT_REV:
-                    SwapComps( 0, 3, pInfo );
-                    SwapComps( 0, 2, pInfo );
-                    break;    // AGR
-                case ADDR_SWAP_STD_REV:
-                    SwapComps( 0, 2, pInfo );
-                    break;    // BGR
-                case ADDR_SWAP_ALT:
-                    SwapComps( 2, 3, pInfo );
-                    break;    // RGA
-                default:
-                    break;    // RGB
-            }
-            break;
-        case 2:
-            switch (swap)
-            {
-                case ADDR_SWAP_ALT_REV:
-                    SwapComps( 0, 1, pInfo );
-                    SwapComps( 1, 3, pInfo );
-                    break;    // AR
-                case ADDR_SWAP_STD_REV:
-                    SwapComps( 0, 1, pInfo );
-                    break;    // GR
-                case ADDR_SWAP_ALT:
-                    SwapComps( 1, 3, pInfo );
-                    break;    // RA
-                default:
-                    break;    // RG
-            }
-            break;
-        case 1:
-            switch (swap)
-            {
-                case ADDR_SWAP_ALT_REV:
-                    SwapComps( 0, 3, pInfo );
-                    break;    // A
-                case ADDR_SWAP_STD_REV:
-                    SwapComps( 0, 2, pInfo );
-                    break;    // B
-                case ADDR_SWAP_ALT:
-                    SwapComps( 0, 1, pInfo );
-                    break;    // G
-                default:
-                    break;    // R
-            }
-            break;
-    }
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::GetCompSwap
-*
-*   @brief
-*       Get components swapped for color surface
-*
-*   @return
-*       N/A
-*
-****************************************************************************************************
-*/
-VOID ElemLib::SwapComps(
-    UINT_32          c0,     ///< [in] component index 0
-    UINT_32          c1,     ///< [in] component index 1
-    PixelFormatInfo* pInfo)  ///< [in,out] output per component info
-{
-    UINT_32 start;
-    UINT_32 bits;
-
-    start = pInfo->compStart[c0];
-    pInfo->compStart[c0] = pInfo->compStart[c1];
-    pInfo->compStart[c1] = start;
-
-    bits  = pInfo->compBit[c0];
-    pInfo->compBit[c0] = pInfo->compBit[c1];
-    pInfo->compBit[c1] = bits;
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::PixGetColorCompInfo
-*
-*   @brief
-*       Get per component info for color surface
-*
-*   @return
-*       N/A
-*
-****************************************************************************************************
-*/
-VOID ElemLib::PixGetColorCompInfo(
-    AddrColorFormat   format, ///< [in] surface format, read from register
-    AddrSurfaceNumber number, ///< [in] pixel number type
-    AddrSurfaceSwap   swap,   ///< [in] component swap mode
-    PixelFormatInfo*  pInfo   ///< [out] output per component info
-    ) const
-{
-    // 1. Get componet bits
-    switch (format)
-    {
-        case ADDR_COLOR_8:
-            GetCompBits(8, 0, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_1_5_5_5:
-            GetCompBits(5, 5, 5, 1, pInfo);
-            break;
-        case ADDR_COLOR_5_6_5:
-            GetCompBits(8, 6, 5, 0, pInfo);
-            break;
-        case ADDR_COLOR_6_5_5:
-            GetCompBits(5, 5, 6, 0, pInfo);
-            break;
-        case ADDR_COLOR_8_8:
-            GetCompBits(8, 8, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_4_4_4_4:
-            GetCompBits(4, 4, 4, 4, pInfo);
-            break;
-        case ADDR_COLOR_16:
-            GetCompBits(16, 0, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_8_8_8_8:
-            GetCompBits(8, 8, 8, 8, pInfo);
-            break;
-        case ADDR_COLOR_2_10_10_10:
-            GetCompBits(10, 10, 10, 2, pInfo);
-            break;
-        case ADDR_COLOR_10_11_11:
-            GetCompBits(11, 11, 10, 0, pInfo);
-            break;
-        case ADDR_COLOR_11_11_10:
-            GetCompBits(10, 11, 11, 0, pInfo);
-            break;
-        case ADDR_COLOR_16_16:
-            GetCompBits(16, 16, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_16_16_16_16:
-            GetCompBits(16, 16, 16, 16, pInfo);
-            break;
-        case ADDR_COLOR_16_FLOAT:
-            GetCompBits(16, 0, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_16_16_FLOAT:
-            GetCompBits(16, 16, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_32_FLOAT:
-            GetCompBits(32, 0, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_32_32_FLOAT:
-            GetCompBits(32, 32, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_16_16_16_16_FLOAT:
-            GetCompBits(16, 16, 16, 16, pInfo);
-            break;
-        case ADDR_COLOR_32_32_32_32_FLOAT:
-            GetCompBits(32, 32, 32, 32, pInfo);
-            break;
-
-        case ADDR_COLOR_32:
-            GetCompBits(32, 0, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_32_32:
-            GetCompBits(32, 32, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_32_32_32_32:
-            GetCompBits(32, 32, 32, 32, pInfo);
-            break;
-        case ADDR_COLOR_10_10_10_2:
-            GetCompBits(2, 10, 10, 10, pInfo);
-            break;
-        case ADDR_COLOR_10_11_11_FLOAT:
-            GetCompBits(11, 11, 10, 0, pInfo);
-            break;
-        case ADDR_COLOR_11_11_10_FLOAT:
-            GetCompBits(10, 11, 11, 0, pInfo);
-            break;
-        case ADDR_COLOR_5_5_5_1:
-            GetCompBits(1, 5, 5, 5, pInfo);
-            break;
-        case ADDR_COLOR_3_3_2:
-            GetCompBits(2, 3, 3, 0, pInfo);
-            break;
-        case ADDR_COLOR_4_4:
-            GetCompBits(4, 4, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_8_24:
-        case ADDR_COLOR_8_24_FLOAT:  // same bit count, fall through
-            GetCompBits(24, 8, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_24_8:
-        case ADDR_COLOR_24_8_FLOAT:  // same bit count, fall through
-            GetCompBits(8, 24, 0, 0, pInfo);
-            break;
-        case ADDR_COLOR_X24_8_32_FLOAT:
-            GetCompBits(32, 8, 0, 0, pInfo);
-            break;
-
-        case ADDR_COLOR_INVALID:
-            GetCompBits(0, 0, 0, 0, pInfo);
-            break;
-        default:
-            ADDR_ASSERT(0);
-            GetCompBits(0, 0, 0, 0, pInfo);
-            break;
-    }
-
-    // 2. Get component number type
-
-    GetCompType(format, number, pInfo);
-
-    // 3. Swap components if needed
-
-    GetCompSwap(swap, pInfo);
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::PixGetDepthCompInfo
-*
-*   @brief
-*       Get per component info for depth surface
-*
-*   @return
-*       N/A
-*
-****************************************************************************************************
-*/
-VOID ElemLib::PixGetDepthCompInfo(
-    AddrDepthFormat  format,     ///< [in] surface format, read from register
-    PixelFormatInfo* pInfo       ///< [out] output per component bits and type
-    ) const
-{
-    if (m_depthPlanarType == ADDR_DEPTH_PLANAR_R800)
-    {
-        if (format == ADDR_DEPTH_8_24_FLOAT)
-        {
-            format = ADDR_DEPTH_X24_8_32_FLOAT; // Use this format to represent R800's D24FS8
-        }
-
-        if (format == ADDR_DEPTH_X8_24_FLOAT)
-        {
-            format = ADDR_DEPTH_32_FLOAT;
-        }
-    }
-
-    switch (format)
-    {
-        case ADDR_DEPTH_16:
-            GetCompBits(16, 0, 0, 0, pInfo);
-            break;
-        case ADDR_DEPTH_8_24:
-        case ADDR_DEPTH_8_24_FLOAT:      // similar format, fall through
-            GetCompBits(24, 8, 0, 0, pInfo);
-            break;
-        case ADDR_DEPTH_X8_24:
-        case ADDR_DEPTH_X8_24_FLOAT:     // similar format, fall through
-            GetCompBits(24, 0, 0, 0, pInfo);
-            break;
-        case ADDR_DEPTH_32_FLOAT:
-            GetCompBits(32, 0, 0, 0, pInfo);
-            break;
-        case ADDR_DEPTH_X24_8_32_FLOAT:
-            GetCompBits(32, 8, 0, 0, pInfo);
-            break;
-        case ADDR_DEPTH_INVALID:
-            GetCompBits(0, 0, 0, 0, pInfo);
-            break;
-        default:
-            ADDR_ASSERT(0);
-            GetCompBits(0, 0, 0, 0, pInfo);
-            break;
-    }
-
-    switch (format)
-    {
-        case ADDR_DEPTH_16:
-            pInfo->numType [0] = ADDR_UNORM_R6XX;
-            pInfo->numType [1] = ADDR_ZERO;
-            break;
-        case ADDR_DEPTH_8_24:
-            pInfo->numType [0] = ADDR_UNORM_R6XXDB;
-            pInfo->numType [1] = ADDR_UINT_BITS;
-            break;
-        case ADDR_DEPTH_8_24_FLOAT:
-            pInfo->numType [0] = ADDR_U4FLOATC;
-            pInfo->numType [1] = ADDR_UINT_BITS;
-            break;
-        case ADDR_DEPTH_X8_24:
-            pInfo->numType [0] = ADDR_UNORM_R6XXDB;
-            pInfo->numType [1] = ADDR_ZERO;
-            break;
-        case ADDR_DEPTH_X8_24_FLOAT:
-            pInfo->numType [0] = ADDR_U4FLOATC;
-            pInfo->numType [1] = ADDR_ZERO;
-            break;
-        case ADDR_DEPTH_32_FLOAT:
-            pInfo->numType [0] = ADDR_S8FLOAT32;
-            pInfo->numType [1] = ADDR_ZERO;
-            break;
-        case ADDR_DEPTH_X24_8_32_FLOAT:
-            pInfo->numType [0] = ADDR_S8FLOAT32;
-            pInfo->numType [1] = ADDR_UINT_BITS;
-            break;
-        default:
-            pInfo->numType [0] = ADDR_NO_NUMBER;
-            pInfo->numType [1] = ADDR_NO_NUMBER;
-            break;
-    }
-
-    pInfo->numType [2] = ADDR_NO_NUMBER;
-    pInfo->numType [3] = ADDR_NO_NUMBER;
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::PixGetExportNorm
-*
-*   @brief
-*       Check if fp16 export norm can be enabled.
-*
-*   @return
-*       TRUE if this can be enabled.
-*
-****************************************************************************************************
-*/
-BOOL_32 ElemLib::PixGetExportNorm(
-    AddrColorFormat     colorFmt,       ///< [in] surface format, read from register
-    AddrSurfaceNumber   numberFmt,      ///< [in] pixel number type
-    AddrSurfaceSwap     swap            ///< [in] components swap type
-    ) const
-{
-    BOOL_32 enabled = TRUE;
-
-    PixelFormatInfo formatInfo;
-
-    PixGetColorCompInfo(colorFmt, numberFmt, swap, &formatInfo);
-
-    for (UINT_32 c = 0; c < 4; c++)
-    {
-        if (m_fp16ExportNorm)
-        {
-            if (((formatInfo.compBit[c] > 11) || (formatInfo.numType[c] > ADDR_USCALED)) &&
-                (formatInfo.numType[c] != ADDR_U4FLOATC)    &&
-                (formatInfo.numType[c] != ADDR_S5FLOAT)     &&
-                (formatInfo.numType[c] != ADDR_S5FLOATM)    &&
-                (formatInfo.numType[c] != ADDR_U5FLOAT)     &&
-                (formatInfo.numType[c] != ADDR_U3FLOATM))
-            {
-                enabled = FALSE;
-                break;
-            }
-        }
-        else
-        {
-            if ((formatInfo.compBit[c] > 11) || (formatInfo.numType[c] > ADDR_USCALED))
-            {
-                enabled = FALSE;
-                break;
-            }
-        }
-    }
-
-    return enabled;
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::AdjustSurfaceInfo
-*
-*   @brief
-*       Adjust bpp/base pitch/width/height according to elemMode and expandX/Y
-*
-*   @return
-*       N/A
-****************************************************************************************************
-*/
-VOID ElemLib::AdjustSurfaceInfo(
-    ElemMode        elemMode,       ///< [in] element mode
-    UINT_32         expandX,        ///< [in] decompression expansion factor in X
-    UINT_32         expandY,        ///< [in] decompression expansion factor in Y
-    UINT_32*        pBpp,           ///< [in,out] bpp
-    UINT_32*        pBasePitch,     ///< [in,out] base pitch
-    UINT_32*        pWidth,         ///< [in,out] width
-    UINT_32*        pHeight)        ///< [in,out] height
-{
-    UINT_32 packedBits;
-    UINT_32 basePitch;
-    UINT_32 width;
-    UINT_32 height;
-    UINT_32 bpp;
-    BOOL_32 bBCnFormat = FALSE;
-
-    ADDR_ASSERT(pBpp != NULL);
-    ADDR_ASSERT(pWidth != NULL && pHeight != NULL && pBasePitch != NULL);
-
-    if (pBpp)
-    {
-        bpp = *pBpp;
-
-        switch (elemMode)
-        {
-            case ADDR_EXPANDED:
-                packedBits = bpp / expandX / expandY;
-                break;
-            case ADDR_PACKED_STD: // Different bit order
-            case ADDR_PACKED_REV:
-                packedBits = bpp * expandX * expandY;
-                break;
-            case ADDR_PACKED_GBGR:
-            case ADDR_PACKED_BGRG:
-                packedBits = bpp; // 32-bit packed ==> 2 32-bit result
-                break;
-            case ADDR_PACKED_BC1: // Fall through
-            case ADDR_PACKED_BC4:
-                packedBits = 64;
-                bBCnFormat = TRUE;
-                break;
-            case ADDR_PACKED_BC2: // Fall through
-            case ADDR_PACKED_BC3: // Fall through
-            case ADDR_PACKED_BC5: // Fall through
-                bBCnFormat = TRUE;
-                // fall through
-            case ADDR_PACKED_ASTC:
-            case ADDR_PACKED_ETC2_128BPP:
-                packedBits = 128;
-                break;
-            case ADDR_PACKED_ETC2_64BPP:
-                packedBits = 64;
-                break;
-            case ADDR_ROUND_BY_HALF:  // Fall through
-            case ADDR_ROUND_TRUNCATE: // Fall through
-            case ADDR_ROUND_DITHER:   // Fall through
-            case ADDR_UNCOMPRESSED:
-                packedBits = bpp;
-                break;
-            default:
-                packedBits = bpp;
-                ADDR_ASSERT_ALWAYS();
-                break;
-        }
-
-        *pBpp = packedBits;
-    }
-
-    if (pWidth && pHeight && pBasePitch)
-    {
-        basePitch = *pBasePitch;
-        width     = *pWidth;
-        height    = *pHeight;
-
-        if ((expandX > 1) || (expandY > 1))
-        {
-            if (elemMode == ADDR_EXPANDED)
-            {
-                basePitch *= expandX;
-                width     *= expandX;
-                height    *= expandY;
-            }
-            else
-            {
-                // Evergreen family workaround
-                if (bBCnFormat && (m_pAddrLib->GetChipFamily() == ADDR_CHIP_FAMILY_R8XX))
-                {
-                    // For BCn we now pad it to POW2 at the beginning so it is safe to
-                    // divide by 4 directly
-                    basePitch = basePitch / expandX;
-                    width     = width  / expandX;
-                    height    = height / expandY;
-#if DEBUG
-                    width     = (width == 0) ? 1 : width;
-                    height    = (height == 0) ? 1 : height;
-
-                    if ((*pWidth > PowTwoAlign(width, 8) * expandX) ||
-                        (*pHeight > PowTwoAlign(height, 8) * expandY)) // 8 is 1D tiling alignment
-                    {
-                        // if this assertion is hit we may have issues if app samples
-                        // rightmost/bottommost pixels
-                        ADDR_ASSERT_ALWAYS();
-                    }
-#endif
-                }
-                else // Not BCn format we still keep old way (FMT_1? No real test yet)
-                {
-                    basePitch = (basePitch + expandX - 1) / expandX;
-                    width     = (width + expandX - 1) / expandX;
-                    height    = (height + expandY - 1) / expandY;
-                }
-            }
-
-            *pBasePitch = basePitch; // 0 is legal value for base pitch.
-            *pWidth     = (width == 0) ? 1 : width;
-            *pHeight    = (height == 0) ? 1 : height;
-        } //if (pWidth && pHeight && pBasePitch)
-    }
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::RestoreSurfaceInfo
-*
-*   @brief
-*       Reverse operation of AdjustSurfaceInfo
-*
-*   @return
-*       N/A
-****************************************************************************************************
-*/
-VOID ElemLib::RestoreSurfaceInfo(
-    ElemMode        elemMode,       ///< [in] element mode
-    UINT_32         expandX,        ///< [in] decompression expansion factor in X
-    UINT_32         expandY,        ///< [out] decompression expansion factor in Y
-    UINT_32*        pBpp,           ///< [in,out] bpp
-    UINT_32*        pWidth,         ///< [in,out] width
-    UINT_32*        pHeight)        ///< [in,out] height
-{
-    UINT_32 originalBits;
-    UINT_32 width;
-    UINT_32 height;
-    UINT_32 bpp;
-
-    BOOL_32 bBCnFormat = FALSE;
-    (void)bBCnFormat;
-
-    ADDR_ASSERT(pBpp != NULL);
-    ADDR_ASSERT(pWidth != NULL && pHeight != NULL);
-
-    if (pBpp)
-    {
-        bpp = *pBpp;
-
-        switch (elemMode)
-        {
-        case ADDR_EXPANDED:
-            originalBits = bpp * expandX * expandY;
-            break;
-        case ADDR_PACKED_STD: // Different bit order
-        case ADDR_PACKED_REV:
-            originalBits = bpp / expandX / expandY;
-            break;
-        case ADDR_PACKED_GBGR:
-        case ADDR_PACKED_BGRG:
-            originalBits = bpp; // 32-bit packed ==> 2 32-bit result
-            break;
-        case ADDR_PACKED_BC1: // Fall through
-        case ADDR_PACKED_BC4:
-            originalBits = 64;
-            bBCnFormat = TRUE;
-            break;
-        case ADDR_PACKED_BC2: // Fall through
-        case ADDR_PACKED_BC3: // Fall through
-        case ADDR_PACKED_BC5:
-            bBCnFormat = TRUE;
-            // fall through
-        case ADDR_PACKED_ASTC:
-        case ADDR_PACKED_ETC2_128BPP:
-            originalBits = 128;
-            break;
-        case ADDR_PACKED_ETC2_64BPP:
-            originalBits = 64;
-            break;
-        case ADDR_ROUND_BY_HALF:  // Fall through
-        case ADDR_ROUND_TRUNCATE: // Fall through
-        case ADDR_ROUND_DITHER:   // Fall through
-        case ADDR_UNCOMPRESSED:
-            originalBits = bpp;
-            break;
-        default:
-            originalBits = bpp;
-            ADDR_ASSERT_ALWAYS();
-            break;
-        }
-
-        *pBpp = originalBits;
-    }
-
-    if (pWidth && pHeight)
-    {
-        width    = *pWidth;
-        height   = *pHeight;
-
-        if ((expandX > 1) || (expandY > 1))
-        {
-            if (elemMode == ADDR_EXPANDED)
-            {
-                width /= expandX;
-                height /= expandY;
-            }
-            else
-            {
-                width *= expandX;
-                height *= expandY;
-            }
-        }
-
-        *pWidth  = (width == 0) ? 1 : width;
-        *pHeight = (height == 0) ? 1 : height;
-    }
-}
-
-/**
-****************************************************************************************************
-*   ElemLib::GetBitsPerPixel
-*
-*   @brief
-*       Compute the total bits per element according to a format
-*       code. For compressed formats, this is not the same as
-*       the number of bits per decompressed element.
-*
-*   @return
-*       Bits per pixel
-****************************************************************************************************
-*/
-UINT_32 ElemLib::GetBitsPerPixel(
-    AddrFormat          format,         ///< [in] surface format code
-    ElemMode*           pElemMode,      ///< [out] element mode
-    UINT_32*            pExpandX,       ///< [out] decompression expansion factor in X
-    UINT_32*            pExpandY,       ///< [out] decompression expansion factor in Y
-    UINT_32*            pUnusedBits)    ///< [out] bits unused
-{
-    UINT_32 bpp;
-    UINT_32 expandX = 1;
-    UINT_32 expandY = 1;
-    UINT_32 bitUnused = 0;
-    ElemMode elemMode = ADDR_UNCOMPRESSED; // default value
-
-    switch (format)
-    {
-        case ADDR_FMT_8:
-            bpp = 8;
-            break;
-        case ADDR_FMT_1_5_5_5:
-        case ADDR_FMT_5_6_5:
-        case ADDR_FMT_6_5_5:
-        case ADDR_FMT_8_8:
-        case ADDR_FMT_4_4_4_4:
-        case ADDR_FMT_16:
-        case ADDR_FMT_16_FLOAT:
-            bpp = 16;
-            break;
-        case ADDR_FMT_GB_GR: // treat as FMT_8_8
-            elemMode = ADDR_PACKED_GBGR;
-            bpp     = 16;
-            break;
-        case ADDR_FMT_BG_RG: // treat as FMT_8_8
-            elemMode = ADDR_PACKED_BGRG;
-            bpp     = 16;
-            break;
-        case ADDR_FMT_8_8_8_8:
-        case ADDR_FMT_2_10_10_10:
-        case ADDR_FMT_10_11_11:
-        case ADDR_FMT_11_11_10:
-        case ADDR_FMT_16_16:
-        case ADDR_FMT_16_16_FLOAT:
-        case ADDR_FMT_32:
-        case ADDR_FMT_32_FLOAT:
-        case ADDR_FMT_24_8:
-        case ADDR_FMT_24_8_FLOAT:
-            bpp = 32;
-            break;
-        case ADDR_FMT_16_16_16_16:
-        case ADDR_FMT_16_16_16_16_FLOAT:
-        case ADDR_FMT_32_32:
-        case ADDR_FMT_32_32_FLOAT:
-        case ADDR_FMT_CTX1:
-            bpp = 64;
-            break;
-        case ADDR_FMT_32_32_32_32:
-        case ADDR_FMT_32_32_32_32_FLOAT:
-            bpp = 128;
-            break;
-        case ADDR_FMT_INVALID:
-            bpp = 0;
-            break;
-        case ADDR_FMT_1_REVERSED:
-            elemMode = ADDR_PACKED_REV;
-            expandX = 8;
-            bpp = 1;
-            break;
-        case ADDR_FMT_1:
-            elemMode = ADDR_PACKED_STD;
-            expandX = 8;
-            bpp = 1;
-            break;
-        case ADDR_FMT_4_4:
-        case ADDR_FMT_3_3_2:
-            bpp = 8;
-            break;
-        case ADDR_FMT_5_5_5_1:
-            bpp = 16;
-            break;
-        case ADDR_FMT_32_AS_8:
-        case ADDR_FMT_32_AS_8_8:
-        case ADDR_FMT_8_24:
-        case ADDR_FMT_8_24_FLOAT:
-        case ADDR_FMT_10_10_10_2:
-        case ADDR_FMT_10_11_11_FLOAT:
-        case ADDR_FMT_11_11_10_FLOAT:
-        case ADDR_FMT_5_9_9_9_SHAREDEXP:
-            bpp = 32;
-            break;
-        case ADDR_FMT_X24_8_32_FLOAT:
-            bpp = 64;
-            bitUnused = 24;
-            break;
-        case ADDR_FMT_8_8_8:
-            elemMode = ADDR_EXPANDED;
-            bpp = 24;//@@ 8;      // read 3 elements per pixel
-            expandX = 3;
-            break;
-        case ADDR_FMT_16_16_16:
-        case ADDR_FMT_16_16_16_FLOAT:
-            elemMode = ADDR_EXPANDED;
-            bpp = 48;//@@ 16;      // read 3 elements per pixel
-            expandX = 3;
-            break;
-        case ADDR_FMT_32_32_32_FLOAT:
-        case ADDR_FMT_32_32_32:
-        &