/*
************************************************************************************************************************
*
*  Copyright (C) 2007-2022 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, sublicense,
* 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 above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* 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 NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) 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
*
***********************************************************************************************************************/

/**
****************************************************************************************************
* @file  addrinterface.h
* @brief Contains the addrlib interfaces declaration and parameter defines
****************************************************************************************************
*/
#ifndef __ADDR_INTERFACE_H__
#define __ADDR_INTERFACE_H__

// Includes should be before extern "C"
#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 forceDccAndTcCompat    : 1;    ///< Force enable DCC and TC compatibility
        UINT_32 nonPower2MemConfig     : 1;    ///< Video memory bit width is not power of 2
        UINT_32 enableAltTiling        : 1;    ///< Enable alt tile mode
        UINT_32 reserved               : 22;   ///< 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
} 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);

/**
****************************************************************************************************
*   ElemSize
*
*   @brief
*       Get bits-per-element for specified format
*
*   @return
*       Bits-per-element of specified format
*
****************************************************************************************************
*/
UINT_32 ADDR_API ElemSize(
    ADDR_HANDLE hLib,
    AddrFormat  format);

/**
****************************************************************************************************
*   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_ALIGNMENTS_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_ALIGNMENTS_OUTPUT;

/**
****************************************************************************************************
*   AddrGetMaxAlignments
*
*   @brief
*       Gets maximnum alignments
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMaxAlignments(
    ADDR_HANDLE                     hLib,
    ADDR_GET_MAX_ALIGNMENTS_OUTPUT* pOut);

/**
****************************************************************************************************
*   AddrGetMaxMetaAlignments
*
*   @brief
*       Gets maximnum alignments for metadata
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMaxMetaAlignments(
    ADDR_HANDLE                     hLib,
    ADDR_GET_MAX_ALIGNMENTS_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 view3dAs2dArray   :  1; ///< This resource is a 3D resource viewed as 2D array
        UINT_32 reserved          : 13; ///< 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;
        };

        // GFX10
        struct
        {
            UINT_32    offset;      ///< Metadata offset within one slice,
                                    ///  the thickness of a slice is meta block depth.
            UINT_32    sliceSize;   ///< Metadata size within one slice,
                                    ///  the thickness of a slice is meta block depth.
        };
    };
} 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;   ///  Id of the first mip in tail,
                                            ///  if no mip is in tail, it should be set to
                                            ///  number of mip levels
                                            ///  Only for GFX10
} 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

    struct {
      UINT_16* gfx10_bits; /* 72 2-byte elements */
   } equation;
} 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
    UINT_32             numMipLevels;       ///< Number of mip levels
    UINT_32             firstMipIdInTail;   ///< The id of first mip in tail, if no mip is in tail,
                                            ///  it should be number of mip levels
                                            ///  Only for GFX10
} ADDR2_COMPUTE_CMASK_INFO_INPUT;

/* DCC addr meta equation for GFX9. */
struct gfx9_addr_meta_equation {
   UINT_8 num_bits;

   struct {
      struct {
         UINT_8 dim; /* 0..4 as index, 5 means invalid */
         UINT_8 ord; /* 0..31 */
      } coord[8]; /* 0..num_coords */
   } bit[32]; /* 0..num_bits */

   UINT_8 numPipeBits;
};

/**
****************************************************************************************************
*   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_META_MIP_INFO* pMipInfo;  ///< CMASK mip information

    /* The equation for doing CMASK address computations in shaders. */
    union {
       /* This is chip-specific, and it varies with:
        * - resource type
        * - swizzle_mode
        * - bpp
        * - pipe_aligned
        * - rb_aligned
        */
       struct gfx9_addr_meta_equation gfx9;

       /* This is chip-specific, it requires 64KB_Z_X. */
       UINT_16 *gfx10_bits; /* 68 2-byte elements */
    } equation;
} 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;   ///< The id of first mip in tail, if no mip is in tail,
                                            ///  it should be number of mip levels
                                            ///  Only for GFX10
} 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    metaBlkSize;        ///< DCC meta block size in bytes
    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;        ///< DCC ram size per slice. For mipmap, it's
                                        ///  the slize size of a mip chain, the thickness of a
                                        ///  a slice is meta block depth
                                        ///  Only for GFX10
    };

    ADDR2_META_MIP_INFO* pMipInfo;      ///< DCC mip information

    /* The equation for doing DCC address computations in shaders. */
    union {
       /* This is chip-specific, and it varies with:
        * - resource type
        * - swizzle_mode
        * - bpp
        * - number of fragments
        * - pipe_aligned
        * - rb_aligned
        */
       struct gfx9_addr_meta_equation gfx9;

       /* This is chip-specific, it requires 64KB_R_X, and it varies with:
        * - bpp
        * - pipe_aligned
        */
       UINT_16 *gfx10_bits; /* 68 2-byte elements */
    } equation;
} 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
    UINT_32             pitch;               ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::pitch
    UINT_32             height;              ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::height
    UINT_32             compressBlkWidth;    ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::compressBlkWidth
    UINT_32             compressBlkHeight;   ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::compressBlkHeight
    UINT_32             compressBlkDepth;    ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::compressBlkDepth
    UINT_32             metaBlkWidth;        ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::metaBlkWidth
    UINT_32             metaBlkHeight;       ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::metaBlkHeight
    UINT_32             metaBlkDepth;        ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::metaBlkDepth
    UINT_32             dccRamSliceSize;     ///< ADDR2_COMPUTE_DCC_INFO_OUTPUT::dccRamSliceSize
} 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             bpe;                ///< bits per element (e.g. block size for BCn format)
    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_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT
*
*   @brief
*       Input structure of Addr2ComputeNonBlockCompressedView
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_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               width;             ///< Width of mip0 in texels (not in compressed block)
    UINT_32               height;            ///< Height of mip0 in texels (not in compressed block) 
    UINT_32               numSlices;         ///< Number surface slice/depth of mip0
    UINT_32               numMipLevels;      ///< Total mipmap levels.
    UINT_32               pipeBankXor;       ///< Combined swizzle used to do bank/pipe rotation
    UINT_32               slice;             ///< Index of slice to view
    UINT_32               mipId;             ///< Id of mip to view
} ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT;

/**
****************************************************************************************************
*   ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT
*
*   @brief
*       Output structure of Addr2ComputeNonBlockCompressedView
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT
{
    UINT_32             size;               ///< Size of this structure in bytes
    UINT_64             offset;             ///< Offset shifted from resource base for the view
    UINT_32             pipeBankXor;        ///< Pipe bank xor for the view
    UINT_32             unalignedWidth;     ///< Mip0 width (in element) for the view
    UINT_32             unalignedHeight;    ///< Mip0 height (in element) for the view
    UINT_32             numMipLevels;       ///< Total mipmap levels for the view
    UINT_32             mipId;              ///< Mip ID for the view
} ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_OUTPUT;

/**
****************************************************************************************************
*   Addr2ComputeNonBlockCompressedView
*
*   @brief
*       Compute non-block-compressed view for a given mipmap level/slice
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeNonBlockCompressedView(
    ADDR_HANDLE                                       hLib,
    const ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_INPUT* pIn,
    ADDR2_COMPUTE_NONBLOCKCOMPRESSEDVIEW_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 macroThin4KB   : 1;   // Thin 4KB for 2D/3D resource
        UINT_32 macroThick4KB  : 1;   // Thick 4KB for 3D resource
        UINT_32 macroThin64KB  : 1;   // Thin 64KB for 2D/3D resource
        UINT_32 macroThick64KB : 1;   // Thick 64KB for 3D resource
        UINT_32 var            : 1;   // VAR block
        UINT_32                : 1;
        UINT_32 linear         : 1;   // Linear block
        UINT_32 reserved       : 24;
    };

    struct
    {
        UINT_32                : 5;
        UINT_32 thin256KB      : 1;   // Thin 256KB block
        UINT_32 thick256KB     : 1;   // Thick 256KB block
        UINT_32                : 25;
    } gfx11;

    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_SWMODE_SET
*
*   @brief
*       Bit field that defines swizzle type
****************************************************************************************************
*/
typedef union _ADDR2_SWMODE_SET
{
    struct
    {
        UINT_32 swLinear    : 1;
        UINT_32 sw256B_S    : 1;
        UINT_32 sw256B_D    : 1;
        UINT_32 sw256B_R    : 1;
        UINT_32 sw4KB_Z     : 1;
        UINT_32 sw4KB_S     : 1;
        UINT_32 sw4KB_D     : 1;
        UINT_32 sw4KB_R     : 1;
        UINT_32 sw64KB_Z    : 1;
        UINT_32 sw64KB_S    : 1;
        UINT_32 sw64KB_D    : 1;
        UINT_32 sw64KB_R    : 1;
        UINT_32 swMiscDef12 : 1;
        UINT_32 swMiscDef13 : 1;
        UINT_32 swMiscDef14 : 1;
        UINT_32 swMiscDef15 : 1;
        UINT_32 sw64KB_Z_T  : 1;
        UINT_32 sw64KB_S_T  : 1;
        UINT_32 sw64KB_D_T  : 1;
        UINT_32 sw64KB_R_T  : 1;
        UINT_32 sw4KB_Z_X   : 1;
        UINT_32 sw4KB_S_X   : 1;
        UINT_32 sw4KB_D_X   : 1;
        UINT_32 sw4KB_R_X   : 1;
        UINT_32 sw64KB_Z_X  : 1;
        UINT_32 sw64KB_S_X  : 1;
        UINT_32 sw64KB_D_X  : 1;
        UINT_32 sw64KB_R_X  : 1;
        UINT_32 swMiscDef28 : 1;
        UINT_32 swMiscDef29 : 1;
        UINT_32 swMiscDef30 : 1;
        UINT_32 swMiscDef31 : 1;
    };

    struct
    {
        UINT_32             : 28;
        UINT_32 swVar_Z_X   : 1;
        UINT_32             : 2;
        UINT_32 swVar_R_X   : 1;
    } gfx10;

    struct
    {
        UINT_32             : 28;
        UINT_32 sw256KB_Z_X : 1;
        UINT_32 sw256KB_S_X : 1;
        UINT_32 sw256KB_D_X : 1;
        UINT_32 sw256KB_R_X : 1;
    } gfx11;

    UINT_32 value;
} ADDR2_SWMODE_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)
    DOUBLE                memoryBudget;      ///< Memory consumption ratio based on minimum possible
                                             ///  size.
} 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_SWMODE_SET      validSwModeSet;       ///< Valid swizzle mode 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 display engine
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
    ADDR_HANDLE     hLib,
    AddrSwizzleMode swizzleMode,
    UINT_32         bpp,
    BOOL_32         *pResult);

#if defined(__cplusplus)
}
#endif

#endif // __ADDR_INTERFACE_H__
