C++程序
|
3704行
|
159.94 KB
/*
* Copyright © 2014 Advanced Micro Devices, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*/
/**
****************************************************************************************************
* @file addrinterface.h
* @brief Contains the addrlib interfaces declaration and parameter defines
****************************************************************************************************
*/
#ifndef __ADDR_INTERFACE_H__
#define __ADDR_INTERFACE_H__
#include "addrtypes.h"
#if defined(__cplusplus)
extern "C"
{
#endif
#define ADDRLIB_VERSION_MAJOR 6
#define ADDRLIB_VERSION_MINOR 2
#define ADDRLIB_VERSION ((ADDRLIB_VERSION_MAJOR << 16) | ADDRLIB_VERSION_MINOR)
/// Virtually all interface functions need ADDR_HANDLE as first parameter
typedef VOID* ADDR_HANDLE;
/// Client handle used in callbacks
typedef VOID* ADDR_CLIENT_HANDLE;
/**
* /////////////////////////////////////////////////////////////////////////////////////////////////
* // Callback functions
* /////////////////////////////////////////////////////////////////////////////////////////////////
* typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
* const ADDR_ALLOCSYSMEM_INPUT* pInput);
* typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
* VOID* pVirtAddr);
* typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
* const ADDR_DEBUGPRINT_INPUT* pInput);
*
* /////////////////////////////////////////////////////////////////////////////////////////////////
* // Create/Destroy/Config functions
* /////////////////////////////////////////////////////////////////////////////////////////////////
* AddrCreate()
* AddrDestroy()
*
* /////////////////////////////////////////////////////////////////////////////////////////////////
* // Surface functions
* /////////////////////////////////////////////////////////////////////////////////////////////////
* AddrComputeSurfaceInfo()
* AddrComputeSurfaceAddrFromCoord()
* AddrComputeSurfaceCoordFromAddr()
*
* /////////////////////////////////////////////////////////////////////////////////////////////////
* // HTile functions
* /////////////////////////////////////////////////////////////////////////////////////////////////
* AddrComputeHtileInfo()
* AddrComputeHtileAddrFromCoord()
* AddrComputeHtileCoordFromAddr()
*
* /////////////////////////////////////////////////////////////////////////////////////////////////
* // C-mask functions
* /////////////////////////////////////////////////////////////////////////////////////////////////
* AddrComputeCmaskInfo()
* AddrComputeCmaskAddrFromCoord()
* AddrComputeCmaskCoordFromAddr()
*
* /////////////////////////////////////////////////////////////////////////////////////////////////
* // F-mask functions
* /////////////////////////////////////////////////////////////////////////////////////////////////
* AddrComputeFmaskInfo()
* AddrComputeFmaskAddrFromCoord()
* AddrComputeFmaskCoordFromAddr()
*
* /////////////////////////////////////////////////////////////////////////////////////////////////
* // Element/Utility functions
* /////////////////////////////////////////////////////////////////////////////////////////////////
* ElemFlt32ToDepthPixel()
* ElemFlt32ToColorPixel()
* AddrExtractBankPipeSwizzle()
* AddrCombineBankPipeSwizzle()
* AddrComputeSliceSwizzle()
* AddrConvertTileInfoToHW()
* AddrConvertTileIndex()
* AddrConvertTileIndex1()
* AddrGetTileIndex()
* AddrComputeBaseSwizzle()
* AddrUseTileIndex()
* AddrUseCombinedSwizzle()
*
**/
////////////////////////////////////////////////////////////////////////////////////////////////////
// Callback functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* @brief channel setting structure
****************************************************************************************************
*/
typedef union _ADDR_CHANNEL_SETTING
{
struct
{
UINT_8 valid : 1; ///< Indicate whehter this channel setting is valid
UINT_8 channel : 2; ///< 0 for x channel, 1 for y channel, 2 for z channel
UINT_8 index : 5; ///< Channel index
};
UINT_8 value; ///< Value
} ADDR_CHANNEL_SETTING;
/**
****************************************************************************************************
* @brief address equation key structure
****************************************************************************************************
*/
typedef union _ADDR_EQUATION_KEY
{
struct
{
UINT_32 log2ElementBytes : 3; ///< Log2 of Bytes per pixel
UINT_32 tileMode : 5; ///< Tile mode
UINT_32 microTileType : 3; ///< Micro tile type
UINT_32 pipeConfig : 5; ///< pipe config
UINT_32 numBanksLog2 : 3; ///< Number of banks log2
UINT_32 bankWidth : 4; ///< Bank width
UINT_32 bankHeight : 4; ///< Bank height
UINT_32 macroAspectRatio : 3; ///< Macro tile aspect ratio
UINT_32 prt : 1; ///< SI only, indicate whether this equation is for prt
UINT_32 reserved : 1; ///< Reserved bit
} fields;
UINT_32 value;
} ADDR_EQUATION_KEY;
/**
****************************************************************************************************
* @brief address equation structure
****************************************************************************************************
*/
#define ADDR_MAX_EQUATION_BIT 20u
// Invalid equation index
#define ADDR_INVALID_EQUATION_INDEX 0xFFFFFFFF
typedef struct _ADDR_EQUATION
{
ADDR_CHANNEL_SETTING addr[ADDR_MAX_EQUATION_BIT]; ///< addr setting
///< each bit is result of addr ^ xor ^ xor2
ADDR_CHANNEL_SETTING xor1[ADDR_MAX_EQUATION_BIT]; ///< xor setting
ADDR_CHANNEL_SETTING xor2[ADDR_MAX_EQUATION_BIT]; ///< xor2 setting
UINT_32 numBits; ///< The number of bits in equation
BOOL_32 stackedDepthSlices; ///< TRUE if depth slices are treated as being
///< stacked vertically prior to swizzling
} ADDR_EQUATION;
/**
****************************************************************************************************
* @brief Alloc system memory flags.
* @note These flags are reserved for future use and if flags are added will minimize the impact
* of the client.
****************************************************************************************************
*/
typedef union _ADDR_ALLOCSYSMEM_FLAGS
{
struct
{
UINT_32 reserved : 32; ///< Reserved for future use.
} fields;
UINT_32 value;
} ADDR_ALLOCSYSMEM_FLAGS;
/**
****************************************************************************************************
* @brief Alloc system memory input structure
****************************************************************************************************
*/
typedef struct _ADDR_ALLOCSYSMEM_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR_ALLOCSYSMEM_FLAGS flags; ///< System memory flags.
UINT_32 sizeInBytes; ///< System memory allocation size in bytes.
ADDR_CLIENT_HANDLE hClient; ///< Client handle
} ADDR_ALLOCSYSMEM_INPUT;
/**
****************************************************************************************************
* ADDR_ALLOCSYSMEM
* @brief
* Allocate system memory callback function. Returns valid pointer on success.
****************************************************************************************************
*/
typedef VOID* (ADDR_API* ADDR_ALLOCSYSMEM)(
const ADDR_ALLOCSYSMEM_INPUT* pInput);
/**
****************************************************************************************************
* @brief Free system memory input structure
****************************************************************************************************
*/
typedef struct _ADDR_FREESYSMEM_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
VOID* pVirtAddr; ///< Virtual address
ADDR_CLIENT_HANDLE hClient; ///< Client handle
} ADDR_FREESYSMEM_INPUT;
/**
****************************************************************************************************
* ADDR_FREESYSMEM
* @brief
* Free system memory callback function.
* Returns ADDR_OK on success.
****************************************************************************************************
*/
typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_FREESYSMEM)(
const ADDR_FREESYSMEM_INPUT* pInput);
/**
****************************************************************************************************
* @brief Print debug message input structure
****************************************************************************************************
*/
typedef struct _ADDR_DEBUGPRINT_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
CHAR* pDebugString; ///< Debug print string
va_list ap; ///< Variable argument list
ADDR_CLIENT_HANDLE hClient; ///< Client handle
} ADDR_DEBUGPRINT_INPUT;
/**
****************************************************************************************************
* ADDR_DEBUGPRINT
* @brief
* Print debug message callback function.
* Returns ADDR_OK on success.
****************************************************************************************************
*/
typedef ADDR_E_RETURNCODE (ADDR_API* ADDR_DEBUGPRINT)(
const ADDR_DEBUGPRINT_INPUT* pInput);
/**
****************************************************************************************************
* ADDR_CALLBACKS
*
* @brief
* Address Library needs client to provide system memory alloc/free routines.
****************************************************************************************************
*/
typedef struct _ADDR_CALLBACKS
{
ADDR_ALLOCSYSMEM allocSysMem; ///< Routine to allocate system memory
ADDR_FREESYSMEM freeSysMem; ///< Routine to free system memory
ADDR_DEBUGPRINT debugPrint; ///< Routine to print debug message
} ADDR_CALLBACKS;
////////////////////////////////////////////////////////////////////////////////////////////////////
// Create/Destroy functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR_CREATE_FLAGS
*
* @brief
* This structure is used to pass some setup in creation of AddrLib
* @note
****************************************************************************************************
*/
typedef union _ADDR_CREATE_FLAGS
{
struct
{
UINT_32 noCubeMipSlicesPad : 1; ///< Turn cubemap faces padding off
UINT_32 fillSizeFields : 1; ///< If clients fill size fields in all input and
/// output structure
UINT_32 useTileIndex : 1; ///< Make tileIndex field in input valid
UINT_32 useCombinedSwizzle : 1; ///< Use combined tile swizzle
UINT_32 checkLast2DLevel : 1; ///< Check the last 2D mip sub level
UINT_32 useHtileSliceAlign : 1; ///< Do htile single slice alignment
UINT_32 allowLargeThickTile : 1; ///< Allow 64*thickness*bytesPerPixel > rowSize
UINT_32 reserved : 25; ///< Reserved bits for future use
};
UINT_32 value;
} ADDR_CREATE_FLAGS;
/**
****************************************************************************************************
* ADDR_REGISTER_VALUE
*
* @brief
* Data from registers to setup AddrLib global data, used in AddrCreate
****************************************************************************************************
*/
typedef struct _ADDR_REGISTER_VALUE
{
UINT_32 gbAddrConfig; ///< For R8xx, use GB_ADDR_CONFIG register value.
/// For R6xx/R7xx, use GB_TILING_CONFIG.
/// But they can be treated as the same.
/// if this value is 0, use chip to set default value
UINT_32 backendDisables; ///< 1 bit per backend, starting with LSB. 1=disabled,0=enabled.
/// Register value of CC_RB_BACKEND_DISABLE.BACKEND_DISABLE
/// R800 registers-----------------------------------------------
UINT_32 noOfBanks; ///< Number of h/w ram banks - For r800: MC_ARB_RAMCFG.NOOFBANK
/// No enums for this value in h/w header files
/// 0: 4
/// 1: 8
/// 2: 16
UINT_32 noOfRanks; /// MC_ARB_RAMCFG.NOOFRANK
/// 0: 1
/// 1: 2
/// SI (R1000) registers-----------------------------------------
const UINT_32* pTileConfig; ///< Global tile setting tables
UINT_32 noOfEntries; ///< Number of entries in pTileConfig
///< CI registers-------------------------------------------------
const UINT_32* pMacroTileConfig; ///< Global macro tile mode table
UINT_32 noOfMacroEntries; ///< Number of entries in pMacroTileConfig
///< GFX9 HW parameters
UINT_32 blockVarSizeLog2; ///< SW_VAR_* block size
} ADDR_REGISTER_VALUE;
/**
****************************************************************************************************
* ADDR_CREATE_INPUT
*
* @brief
* Parameters use to create an AddrLib Object. Caller must provide all fields.
*
****************************************************************************************************
*/
typedef struct _ADDR_CREATE_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 chipEngine; ///< Chip Engine
UINT_32 chipFamily; ///< Chip Family
UINT_32 chipRevision; ///< Chip Revision
ADDR_CALLBACKS callbacks; ///< Callbacks for sysmem alloc/free/print
ADDR_CREATE_FLAGS createFlags; ///< Flags to setup AddrLib
ADDR_REGISTER_VALUE regValue; ///< Data from registers to setup AddrLib global data
ADDR_CLIENT_HANDLE hClient; ///< Client handle
UINT_32 minPitchAlignPixels; ///< Minimum pitch alignment in pixels
} ADDR_CREATE_INPUT;
/**
****************************************************************************************************
* ADDR_CREATEINFO_OUTPUT
*
* @brief
* Return AddrLib handle to client driver
*
****************************************************************************************************
*/
typedef struct _ADDR_CREATE_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR_HANDLE hLib; ///< Address lib handle
UINT_32 numEquations; ///< Number of equations in the table
const ADDR_EQUATION* pEquationTable; ///< Pointer to the equation table
} ADDR_CREATE_OUTPUT;
/**
****************************************************************************************************
* AddrCreate
*
* @brief
* Create AddrLib object, must be called before any interface calls
*
* @return
* ADDR_OK if successful
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCreate(
const ADDR_CREATE_INPUT* pAddrCreateIn,
ADDR_CREATE_OUTPUT* pAddrCreateOut);
/**
****************************************************************************************************
* AddrDestroy
*
* @brief
* Destroy AddrLib object, must be called to free internally allocated resources.
*
* @return
* ADDR_OK if successful
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrDestroy(
ADDR_HANDLE hLib);
////////////////////////////////////////////////////////////////////////////////////////////////////
// Surface functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* @brief
* Bank/tiling parameters. On function input, these can be set as desired or
* left 0 for AddrLib to calculate/default. On function output, these are the actual
* parameters used.
* @note
* Valid bankWidth/bankHeight value:
* 1,2,4,8. They are factors instead of pixels or bytes.
*
* The bank number remains constant across each row of the
* macro tile as each pipe is selected, so the number of
* tiles in the x direction with the same bank number will
* be bank_width * num_pipes.
****************************************************************************************************
*/
typedef struct _ADDR_TILEINFO
{
/// Any of these parameters can be set to 0 to use the HW default.
UINT_32 banks; ///< Number of banks, numerical value
UINT_32 bankWidth; ///< Number of tiles in the X direction in the same bank
UINT_32 bankHeight; ///< Number of tiles in the Y direction in the same bank
UINT_32 macroAspectRatio; ///< Macro tile aspect ratio. 1-1:1, 2-4:1, 4-16:1, 8-64:1
UINT_32 tileSplitBytes; ///< Tile split size, in bytes
AddrPipeCfg pipeConfig; ///< Pipe Config = HW enum + 1
} ADDR_TILEINFO;
// Create a define to avoid client change. The removal of R800 is because we plan to implement SI
// within 800 HWL - An AddrPipeCfg is added in above data structure
typedef ADDR_TILEINFO ADDR_R800_TILEINFO;
/**
****************************************************************************************************
* @brief
* Information needed by quad buffer stereo support
****************************************************************************************************
*/
typedef struct _ADDR_QBSTEREOINFO
{
UINT_32 eyeHeight; ///< Height (in pixel rows) to right eye
UINT_32 rightOffset; ///< Offset (in bytes) to right eye
UINT_32 rightSwizzle; ///< TileSwizzle for right eyes
} ADDR_QBSTEREOINFO;
/**
****************************************************************************************************
* ADDR_SURFACE_FLAGS
*
* @brief
* Surface flags
****************************************************************************************************
*/
typedef union _ADDR_SURFACE_FLAGS
{
struct
{
UINT_32 color : 1; ///< Flag indicates this is a color buffer
UINT_32 depth : 1; ///< Flag indicates this is a depth/stencil buffer
UINT_32 stencil : 1; ///< Flag indicates this is a stencil buffer
UINT_32 texture : 1; ///< Flag indicates this is a texture
UINT_32 cube : 1; ///< Flag indicates this is a cubemap
UINT_32 volume : 1; ///< Flag indicates this is a volume texture
UINT_32 fmask : 1; ///< Flag indicates this is an fmask
UINT_32 cubeAsArray : 1; ///< Flag indicates if treat cubemap as arrays
UINT_32 compressZ : 1; ///< Flag indicates z buffer is compressed
UINT_32 overlay : 1; ///< Flag indicates this is an overlay surface
UINT_32 noStencil : 1; ///< Flag indicates this depth has no separate stencil
UINT_32 display : 1; ///< Flag indicates this should match display controller req.
UINT_32 opt4Space : 1; ///< Flag indicates this surface should be optimized for space
/// i.e. save some memory but may lose performance
UINT_32 prt : 1; ///< Flag for partially resident texture
UINT_32 qbStereo : 1; ///< Quad buffer stereo surface
UINT_32 pow2Pad : 1; ///< SI: Pad to pow2, must set for mipmap (include level0)
UINT_32 interleaved : 1; ///< Special flag for interleaved YUV surface padding
UINT_32 tcCompatible : 1; ///< Flag indicates surface needs to be shader readable
UINT_32 dispTileType : 1; ///< NI: force display Tiling for 128 bit shared resoruce
UINT_32 dccCompatible : 1; ///< VI: whether to make MSAA surface support dcc fast clear
UINT_32 dccPipeWorkaround : 1; ///< VI: whether to workaround the HW limit that
/// dcc can't be enabled if pipe config of tile mode
/// is different from that of ASIC, this flag
/// is address lib internal flag, client should ignore it
UINT_32 czDispCompatible : 1; ///< SI+: CZ family has a HW bug needs special alignment.
/// This flag indicates we need to follow the
/// alignment with CZ families or other ASICs under
/// PX configuration + CZ.
UINT_32 nonSplit : 1; ///< CI: depth texture should not be split
UINT_32 disableLinearOpt : 1; ///< Disable tile mode optimization to linear
UINT_32 needEquation : 1; ///< Make the surface tile setting equation compatible.
/// This flag indicates we need to override tile
/// mode to PRT_* tile mode to disable slice rotation,
/// which is needed by swizzle pattern equation.
UINT_32 skipIndicesOutput : 1; ///< Skipping indices in output.
UINT_32 rotateDisplay : 1; ///< Rotate micro tile type
UINT_32 minimizeAlignment : 1; ///< Minimize alignment
UINT_32 preferEquation : 1; ///< Return equation index without adjusting tile mode
UINT_32 matchStencilTileCfg : 1; ///< Select tile index of stencil as well as depth surface
/// to make sure they share same tile config parameters
UINT_32 reserved : 2; ///< Reserved bits
};
UINT_32 value;
} ADDR_SURFACE_FLAGS;
/**
****************************************************************************************************
* ADDR_COMPUTE_SURFACE_INFO_INPUT
*
* @brief
* Input structure for AddrComputeSurfaceInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_INFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrTileMode tileMode; ///< Tile mode
AddrFormat format; ///< If format is set to valid one, bpp/width/height
/// might be overwritten
UINT_32 bpp; ///< Bits per pixel
UINT_32 numSamples; ///< Number of samples
UINT_32 width; ///< Width, in pixels
UINT_32 height; ///< Height, in pixels
UINT_32 numSlices; ///< Number of surface slices or depth
UINT_32 slice; ///< Slice index
UINT_32 mipLevel; ///< Current mipmap level
UINT_32 numMipLevels; ///< Number of mips in mip chain
ADDR_SURFACE_FLAGS flags; ///< Surface type flags
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
/// r800 and later HWL parameters
// Needed by 2D tiling, for linear and 1D tiling, just keep them 0's
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Set to 0 to default/calculate
AddrTileType tileType; ///< Micro tiling type, not needed when tileIndex != -1
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
UINT_32 basePitch; ///< Base level pitch in pixels, 0 means ignored, is a
/// must for mip levels from SI+.
/// Don't use pitch in blocks for compressed formats!
UINT_32 maxBaseAlign; ///< Max base alignment request from client
UINT_32 pitchAlign; ///< Pitch alignment request from client
UINT_32 heightAlign; ///< Height alignment request from client
} ADDR_COMPUTE_SURFACE_INFO_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_SURFACE_INFO_OUTPUT
*
* @brief
* Output structure for AddrComputeSurfInfo
* @note
Element: AddrLib unit for computing. e.g. BCn: 4x4 blocks; R32B32B32: 32bit with 3x pitch
Pixel: Original pixel
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch in elements (in blocks for compressed formats)
UINT_32 height; ///< Height in elements (in blocks for compressed formats)
UINT_32 depth; ///< Number of slice/depth
UINT_64 surfSize; ///< Surface size in bytes
AddrTileMode tileMode; ///< Actual tile mode. May differ from that in input
UINT_32 baseAlign; ///< Base address alignment
UINT_32 pitchAlign; ///< Pitch alignment, in elements
UINT_32 heightAlign; ///< Height alignment, in elements
UINT_32 depthAlign; ///< Depth alignment, aligned to thickness, for 3d texture
UINT_32 bpp; ///< Bits per elements (e.g. blocks for BCn, 1/3 for 96bit)
UINT_32 pixelPitch; ///< Pitch in original pixels
UINT_32 pixelHeight; ///< Height in original pixels
UINT_32 pixelBits; ///< Original bits per pixel, passed from input
UINT_64 sliceSize; ///< Size of slice specified by input's slice
/// The result is controlled by surface flags & createFlags
/// By default this value equals to surfSize for volume
UINT_32 pitchTileMax; ///< PITCH_TILE_MAX value for h/w register
UINT_32 heightTileMax; ///< HEIGHT_TILE_MAX value for h/w register
UINT_32 sliceTileMax; ///< SLICE_TILE_MAX value for h/w register
UINT_32 numSamples; ///< Pass the effective numSamples processed in this call
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< Tile parameters used. Filled in if 0 on input
AddrTileType tileType; ///< Micro tiling type, only valid when tileIndex != -1
INT_32 tileIndex; ///< Tile index, MAY be "downgraded"
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
/// Output flags
struct
{
/// Special information to work around SI mipmap swizzle bug UBTS #317508
UINT_32 last2DLevel : 1; ///< TRUE if this is the last 2D(3D) tiled
///< Only meaningful when create flag checkLast2DLevel is set
UINT_32 tcCompatible : 1; ///< If the surface can be shader compatible
UINT_32 dccUnsupport : 1; ///< If the surface can support DCC compressed rendering
UINT_32 prtTileIndex : 1; ///< SI only, indicate the returned tile index is for PRT
///< If address lib return true for mip 0, client should set prt flag
///< for child mips in subsequent compute surface info calls
UINT_32 reserved :28; ///< Reserved bits
};
UINT_32 equationIndex; ///< Equation index in the equation table;
UINT_32 blockWidth; ///< Width in element inside one block(1D->Micro, 2D->Macro)
UINT_32 blockHeight; ///< Height in element inside one block(1D->Micro, 2D->Macro)
UINT_32 blockSlices; ///< Slice number inside one block(1D->Micro, 2D->Macro)
/// Stereo info
ADDR_QBSTEREOINFO* pStereoInfo;///< Stereo information, needed when .qbStereo flag is TRUE
INT_32 stencilTileIdx; ///< stencil tile index output when matchStencilTileCfg was set
} ADDR_COMPUTE_SURFACE_INFO_OUTPUT;
/**
****************************************************************************************************
* AddrComputeSurfaceInfo
*
* @brief
* Compute surface width/height/depth/alignments and suitable tiling mode
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn,
ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeSurfaceAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
UINT_32 sample; ///< Sample index, use fragment index for EQAA
UINT_32 bpp; ///< Bits per pixel
UINT_32 pitch; ///< Surface pitch, in pixels
UINT_32 height; ///< Surface height, in pixels
UINT_32 numSlices; ///< Surface depth
UINT_32 numSamples; ///< Number of samples
AddrTileMode tileMode; ///< Tile mode
BOOL_32 isDepth; ///< TRUE if the surface uses depth sample ordering within
/// micro tile. Textures can also choose depth sample order
UINT_32 tileBase; ///< Base offset (in bits) inside micro tile which handles
/// the case that components are stored separately
UINT_32 compBits; ///< The component bits actually needed(for planar surface)
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
/// r800 and later HWL parameters
// Used for 1D tiling above
AddrTileType tileType; ///< See defintion of AddrTileType
struct
{
UINT_32 ignoreSE : 1; ///< TRUE if shader engines are ignored. This is texture
/// only flag. Only non-RT texture can set this to TRUE
UINT_32 reserved :31; ///< Reserved for future use.
};
// 2D tiling needs following structure
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Client must provide all data
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
union
{
struct
{
UINT_32 bankSwizzle; ///< Bank swizzle
UINT_32 pipeSwizzle; ///< Pipe swizzle
};
UINT_32 tileSwizzle; ///< Combined swizzle, if useCombinedSwizzle is TRUE
};
} ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeSurfaceAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Byte address
UINT_32 bitPosition; ///< Bit position within surfaceAddr, 0-7.
/// For surface bpp < 8, e.g. FMT_1.
UINT_32 prtBlockIndex; ///< Index of a PRT tile (64K block)
} ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* AddrComputeSurfaceAddrFromCoord
*
* @brief
* Compute surface address from a given coordinate.
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeSurfaceCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address in bytes
UINT_32 bitPosition; ///< Bit position in addr. 0-7. for surface bpp < 8,
/// e.g. FMT_1;
UINT_32 bpp; ///< Bits per pixel
UINT_32 pitch; ///< Pitch, in pixels
UINT_32 height; ///< Height in pixels
UINT_32 numSlices; ///< Surface depth
UINT_32 numSamples; ///< Number of samples
AddrTileMode tileMode; ///< Tile mode
BOOL_32 isDepth; ///< Surface uses depth sample ordering within micro tile.
/// Note: Textures can choose depth sample order as well.
UINT_32 tileBase; ///< Base offset (in bits) inside micro tile which handles
/// the case that components are stored separately
UINT_32 compBits; ///< The component bits actually needed(for planar surface)
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
/// r800 and later HWL parameters
// Used for 1D tiling above
AddrTileType tileType; ///< See defintion of AddrTileType
struct
{
UINT_32 ignoreSE : 1; ///< TRUE if shader engines are ignored. This is texture
/// only flag. Only non-RT texture can set this to TRUE
UINT_32 reserved :31; ///< Reserved for future use.
};
// 2D tiling needs following structure
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Client must provide all data
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
union
{
struct
{
UINT_32 bankSwizzle; ///< Bank swizzle
UINT_32 pipeSwizzle; ///< Pipe swizzle
};
UINT_32 tileSwizzle; ///< Combined swizzle, if useCombinedSwizzle is TRUE
};
} ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeSurfaceCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slices
UINT_32 sample; ///< Index of samples, means fragment index for EQAA
} ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* AddrComputeSurfaceCoordFromAddr
*
* @brief
* Compute coordinate from a given surface address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// HTile functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR_HTILE_FLAGS
*
* @brief
* HTILE flags
****************************************************************************************************
*/
typedef union _ADDR_HTILE_FLAGS
{
struct
{
UINT_32 tcCompatible : 1; ///< Flag indicates surface needs to be shader readable
UINT_32 skipTcCompatSizeAlign : 1; ///< Flag indicates that addrLib will not align htile
/// size to 256xBankxPipe when computing tc-compatible
/// htile info.
UINT_32 reserved : 30; ///< Reserved bits
};
UINT_32 value;
} ADDR_HTILE_FLAGS;
/**
****************************************************************************************************
* ADDR_COMPUTE_HTILE_INFO_INPUT
*
* @brief
* Input structure of AddrComputeHtileInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_INFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR_HTILE_FLAGS flags; ///< HTILE flags
UINT_32 pitch; ///< Surface pitch, in pixels
UINT_32 height; ///< Surface height, in pixels
UINT_32 numSlices; ///< Number of slices
BOOL_32 isLinear; ///< Linear or tiled HTILE layout
AddrHtileBlockSize blockWidth; ///< 4 or 8. EG above only support 8
AddrHtileBlockSize blockHeight; ///< 4 or 8. EG above only support 8
ADDR_TILEINFO* pTileInfo; ///< Tile info
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_HTILE_INFO_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_HTILE_INFO_OUTPUT
*
* @brief
* Output structure of AddrComputeHtileInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch in pixels of depth buffer represented in this
/// HTile buffer. This might be larger than original depth
/// buffer pitch when called with an unaligned pitch.
UINT_32 height; ///< Height in pixels, as above
UINT_64 htileBytes; ///< Size of HTILE buffer, in bytes
UINT_32 baseAlign; ///< Base alignment
UINT_32 bpp; ///< Bits per pixel for HTILE is how many bits for an 8x8 block!
UINT_32 macroWidth; ///< Macro width in pixels, actually squared cache shape
UINT_32 macroHeight; ///< Macro height in pixels
UINT_64 sliceSize; ///< Slice size, in bytes.
BOOL_32 sliceInterleaved; ///< Flag to indicate if different slice's htile is interleaved
/// Compute engine clear can't be used if htile is interleaved
BOOL_32 nextMipLevelCompressible; ///< Flag to indicate whether HTILE can be enabled in
/// next mip level, it also indicates if memory set based
/// fast clear can be used for current mip level.
} ADDR_COMPUTE_HTILE_INFO_OUTPUT;
/**
****************************************************************************************************
* AddrComputeHtileInfo
*
* @brief
* Compute Htile pitch, height, base alignment and size in bytes
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn,
ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeHtileAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch, in pixels
UINT_32 height; ///< Height in pixels
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slice
UINT_32 numSlices; ///< Number of slices
BOOL_32 isLinear; ///< Linear or tiled HTILE layout
ADDR_HTILE_FLAGS flags; ///< htile flags
AddrHtileBlockSize blockWidth; ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
AddrHtileBlockSize blockHeight; ///< 4 or 8. 1 means 8, 0 means 4. EG above only support 8
ADDR_TILEINFO* pTileInfo; ///< Tile info
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
UINT_32 bpp; ///< depth/stencil buffer bit per pixel size
UINT_32 zStencilAddr; ///< tcCompatible Z/Stencil surface address
} ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeHtileAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address in bytes
UINT_32 bitPosition; ///< Bit position, 0 or 4. CMASK and HTILE shares some lib method.
/// So we keep bitPosition for HTILE as well
} ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* AddrComputeHtileAddrFromCoord
*
* @brief
* Compute Htile address according to coordinates (of depth buffer)
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn,
ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeHtileCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address
UINT_32 bitPosition; ///< Bit position 0 or 4. CMASK and HTILE share some methods
/// so we keep bitPosition for HTILE as well
UINT_32 pitch; ///< Pitch, in pixels
UINT_32 height; ///< Height, in pixels
UINT_32 numSlices; ///< Number of slices
BOOL_32 isLinear; ///< Linear or tiled HTILE layout
AddrHtileBlockSize blockWidth; ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
AddrHtileBlockSize blockHeight; ///< 4 or 8. 1 means 8, 0 means 4. R8xx/R9xx only support 8
ADDR_TILEINFO* pTileInfo; ///< Tile info
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeHtileCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
} ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* AddrComputeHtileCoordFromAddr
*
* @brief
* Compute coordinates within depth buffer (1st pixel of a micro tile) according to
* Htile address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn,
ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// C-mask functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR_CMASK_FLAGS
*
* @brief
* CMASK flags
****************************************************************************************************
*/
typedef union _ADDR_CMASK_FLAGS
{
struct
{
UINT_32 tcCompatible : 1; ///< Flag indicates surface needs to be shader readable
UINT_32 reserved :31; ///< Reserved bits
};
UINT_32 value;
} ADDR_CMASK_FLAGS;
/**
****************************************************************************************************
* ADDR_COMPUTE_CMASK_INFO_INPUT
*
* @brief
* Input structure of AddrComputeCmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASKINFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR_CMASK_FLAGS flags; ///< CMASK flags
UINT_32 pitch; ///< Pitch, in pixels, of color buffer
UINT_32 height; ///< Height, in pixels, of color buffer
UINT_32 numSlices; ///< Number of slices, of color buffer
BOOL_32 isLinear; ///< Linear or tiled layout, Only SI can be linear
ADDR_TILEINFO* pTileInfo; ///< Tile info
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_CMASK_INFO_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_CMASK_INFO_OUTPUT
*
* @brief
* Output structure of AddrComputeCmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch in pixels of color buffer which
/// this Cmask matches. The size might be larger than
/// original color buffer pitch when called with
/// an unaligned pitch.
UINT_32 height; ///< Height in pixels, as above
UINT_64 cmaskBytes; ///< Size in bytes of CMask buffer
UINT_32 baseAlign; ///< Base alignment
UINT_32 blockMax; ///< Cmask block size. Need this to set CB_COLORn_MASK register
UINT_32 macroWidth; ///< Macro width in pixels, actually squared cache shape
UINT_32 macroHeight; ///< Macro height in pixels
UINT_64 sliceSize; ///< Slice size, in bytes.
} ADDR_COMPUTE_CMASK_INFO_OUTPUT;
/**
****************************************************************************************************
* AddrComputeCmaskInfo
*
* @brief
* Compute Cmask pitch, height, base alignment and size in bytes from color buffer
* info
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn,
ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeCmaskAddrFromCoord
*
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_64 fmaskAddr; ///< Fmask addr for tc compatible Cmask
UINT_32 slice; ///< Slice index
UINT_32 pitch; ///< Pitch in pixels, of color buffer
UINT_32 height; ///< Height in pixels, of color buffer
UINT_32 numSlices; ///< Number of slices
UINT_32 bpp;
BOOL_32 isLinear; ///< Linear or tiled layout, Only SI can be linear
ADDR_CMASK_FLAGS flags; ///< CMASK flags
ADDR_TILEINFO* pTileInfo; ///< Tile info
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
///< while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeCmaskAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< CMASK address in bytes
UINT_32 bitPosition; ///< Bit position within addr, 0-7. CMASK is 4 bpp,
/// so the address may be located in bit 0 (0) or 4 (4)
} ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* AddrComputeCmaskAddrFromCoord
*
* @brief
* Compute Cmask address according to coordinates (of MSAA color buffer)
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn,
ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeCmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< CMASK address in bytes
UINT_32 bitPosition; ///< Bit position within addr, 0-7. CMASK is 4 bpp,
/// so the address may be located in bit 0 (0) or 4 (4)
UINT_32 pitch; ///< Pitch, in pixels
UINT_32 height; ///< Height in pixels
UINT_32 numSlices; ///< Number of slices
BOOL_32 isLinear; ///< Linear or tiled layout, Only SI can be linear
ADDR_TILEINFO* pTileInfo; ///< Tile info
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeCmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
} ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* AddrComputeCmaskCoordFromAddr
*
* @brief
* Compute coordinates within color buffer (1st pixel of a micro tile) according to
* Cmask address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn,
ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// F-mask functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR_COMPUTE_FMASK_INFO_INPUT
*
* @brief
* Input structure for AddrComputeFmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_INFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrTileMode tileMode; ///< Tile mode
UINT_32 pitch; ///< Surface pitch, in pixels
UINT_32 height; ///< Surface height, in pixels
UINT_32 numSlices; ///< Number of slice/depth
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
/// r800 and later HWL parameters
struct
{
UINT_32 resolved: 1; ///< TRUE if the surface is for resolved fmask, only used
/// by H/W clients. S/W should always set it to FALSE.
UINT_32 reserved: 31; ///< Reserved for future use.
};
ADDR_TILEINFO* pTileInfo; ///< 2D tiling parameters. Clients must give valid data
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
} ADDR_COMPUTE_FMASK_INFO_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_FMASK_INFO_OUTPUT
*
* @brief
* Output structure for AddrComputeFmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch of fmask in pixels
UINT_32 height; ///< Height of fmask in pixels
UINT_32 numSlices; ///< Slices of fmask
UINT_64 fmaskBytes; ///< Size of fmask in bytes
UINT_32 baseAlign; ///< Base address alignment
UINT_32 pitchAlign; ///< Pitch alignment
UINT_32 heightAlign; ///< Height alignment
UINT_32 bpp; ///< Bits per pixel of FMASK is: number of bit planes
UINT_32 numSamples; ///< Number of samples, used for dump, export this since input
/// may be changed in 9xx and above
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< Tile parameters used. Fmask can have different
/// bank_height from color buffer
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
UINT_64 sliceSize; ///< Size of slice in bytes
} ADDR_COMPUTE_FMASK_INFO_OUTPUT;
/**
****************************************************************************************************
* AddrComputeFmaskInfo
*
* @brief
* Compute Fmask pitch/height/depth/alignments and size in bytes
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn,
ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for AddrComputeFmaskAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
UINT_32 plane; ///< Plane number
UINT_32 sample; ///< Sample index (fragment index for EQAA)
UINT_32 pitch; ///< Surface pitch, in pixels
UINT_32 height; ///< Surface height, in pixels
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
AddrTileMode tileMode; ///< Tile mode
union
{
struct
{
UINT_32 bankSwizzle; ///< Bank swizzle
UINT_32 pipeSwizzle; ///< Pipe swizzle
};
UINT_32 tileSwizzle; ///< Combined swizzle, if useCombinedSwizzle is TRUE
};
/// r800 and later HWL parameters
struct
{
UINT_32 resolved: 1; ///< TRUE if this is a resolved fmask, used by H/W clients
UINT_32 ignoreSE: 1; ///< TRUE if shader engines are ignored.
UINT_32 reserved: 30; ///< Reserved for future use.
};
ADDR_TILEINFO* pTileInfo; ///< 2D tiling parameters. Client must provide all data
} ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for AddrComputeFmaskAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Fmask address
UINT_32 bitPosition; ///< Bit position within fmaskAddr, 0-7.
} ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* AddrComputeFmaskAddrFromCoord
*
* @brief
* Compute Fmask address according to coordinates (x,y,slice,sample,plane)
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn,
ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
*
* @brief
* Input structure for AddrComputeFmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address
UINT_32 bitPosition; ///< Bit position within addr, 0-7.
UINT_32 pitch; ///< Pitch, in pixels
UINT_32 height; ///< Height in pixels
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments
AddrTileMode tileMode; ///< Tile mode
union
{
struct
{
UINT_32 bankSwizzle; ///< Bank swizzle
UINT_32 pipeSwizzle; ///< Pipe swizzle
};
UINT_32 tileSwizzle; ///< Combined swizzle, if useCombinedSwizzle is TRUE
};
/// r800 and later HWL parameters
struct
{
UINT_32 resolved: 1; ///< TRUE if this is a resolved fmask, used by HW components
UINT_32 ignoreSE: 1; ///< TRUE if shader engines are ignored.
UINT_32 reserved: 30; ///< Reserved for future use.
};
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Client must provide all data
} ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for AddrComputeFmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
UINT_32 plane; ///< Plane number
UINT_32 sample; ///< Sample index (fragment index for EQAA)
} ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* AddrComputeFmaskCoordFromAddr
*
* @brief
* Compute FMASK coordinate from an given address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn,
ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// Element/utility functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* AddrGetVersion
*
* @brief
* Get AddrLib version number
****************************************************************************************************
*/
UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib);
/**
****************************************************************************************************
* AddrUseTileIndex
*
* @brief
* Return TRUE if tileIndex is enabled in this address library
****************************************************************************************************
*/
BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib);
/**
****************************************************************************************************
* AddrUseCombinedSwizzle
*
* @brief
* Return TRUE if combined swizzle is enabled in this address library
****************************************************************************************************
*/
BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib);
/**
****************************************************************************************************
* ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
*
* @brief
* Input structure of AddrExtractBankPipeSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 base256b; ///< Base256b value
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Client must provide all data
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT;
/**
****************************************************************************************************
* ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrExtractBankPipeSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 bankSwizzle; ///< Bank swizzle
UINT_32 pipeSwizzle; ///< Pipe swizzle
} ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT;
/**
****************************************************************************************************
* AddrExtractBankPipeSwizzle
*
* @brief
* Extract Bank and Pipe swizzle from base256b
* @return
* ADDR_OK if no error
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle(
ADDR_HANDLE hLib,
const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn,
ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
*
* @brief
* Input structure of AddrCombineBankPipeSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 bankSwizzle; ///< Bank swizzle
UINT_32 pipeSwizzle; ///< Pipe swizzle
UINT_64 baseAddr; ///< Base address (leave it zero for driver clients)
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Client must provide all data
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT;
/**
****************************************************************************************************
* ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrCombineBankPipeSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 tileSwizzle; ///< Combined swizzle
} ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT;
/**
****************************************************************************************************
* AddrCombineBankPipeSwizzle
*
* @brief
* Combine Bank and Pipe swizzle
* @return
* ADDR_OK if no error
* @note
* baseAddr here is full MCAddress instead of base256b
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle(
ADDR_HANDLE hLib,
const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn,
ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_COMPUTE_SLICESWIZZLE_INPUT
*
* @brief
* Input structure of AddrComputeSliceSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SLICESWIZZLE_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrTileMode tileMode; ///< Tile Mode
UINT_32 baseSwizzle; ///< Base tile swizzle
UINT_32 slice; ///< Slice index
UINT_64 baseAddr; ///< Base address, driver should leave it 0 in most cases
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Actually banks needed here!
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_SLICESWIZZLE_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrComputeSliceSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_SLICESWIZZLE_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 tileSwizzle; ///< Recalculated tileSwizzle value
} ADDR_COMPUTE_SLICESWIZZLE_OUTPUT;
/**
****************************************************************************************************
* AddrComputeSliceSwizzle
*
* @brief
* Extract Bank and Pipe swizzle from base256b
* @return
* ADDR_OK if no error
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn,
ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut);
/**
****************************************************************************************************
* AddrSwizzleGenOption
*
* @brief
* Which swizzle generating options: legacy or linear
****************************************************************************************************
*/
typedef enum _AddrSwizzleGenOption
{
ADDR_SWIZZLE_GEN_DEFAULT = 0, ///< As is in client driver implemention for swizzle
ADDR_SWIZZLE_GEN_LINEAR = 1, ///< Using a linear increment of swizzle
} AddrSwizzleGenOption;
/**
****************************************************************************************************
* AddrSwizzleOption
*
* @brief
* Controls how swizzle is generated
****************************************************************************************************
*/
typedef union _ADDR_SWIZZLE_OPTION
{
struct
{
UINT_32 genOption : 1; ///< The way swizzle is generated, see AddrSwizzleGenOption
UINT_32 reduceBankBit : 1; ///< TRUE if we need reduce swizzle bits
UINT_32 reserved :30; ///< Reserved bits
};
UINT_32 value;
} ADDR_SWIZZLE_OPTION;
/**
****************************************************************************************************
* ADDR_COMPUTE_BASE_SWIZZLE_INPUT
*
* @brief
* Input structure of AddrComputeBaseSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR_SWIZZLE_OPTION option; ///< Swizzle option
UINT_32 surfIndex; ///< Index of this surface type
AddrTileMode tileMode; ///< Tile Mode
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< 2D tile parameters. Actually banks needed here!
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_BASE_SWIZZLE_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
*
* @brief
* Output structure of AddrComputeBaseSwizzle
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 tileSwizzle; ///< Combined swizzle
} ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT;
/**
****************************************************************************************************
* AddrComputeBaseSwizzle
*
* @brief
* Return a Combined Bank and Pipe swizzle base on surface based on surface type/index
* @return
* ADDR_OK if no error
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle(
ADDR_HANDLE hLib,
const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn,
ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut);
/**
****************************************************************************************************
* ELEM_GETEXPORTNORM_INPUT
*
* @brief
* Input structure for ElemGetExportNorm
*
****************************************************************************************************
*/
typedef struct _ELEM_GETEXPORTNORM_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrColorFormat format; ///< Color buffer format; Client should use ColorFormat
AddrSurfaceNumber num; ///< Surface number type; Client should use NumberType
AddrSurfaceSwap swap; ///< Surface swap byte swap; Client should use SurfaceSwap
UINT_32 numSamples; ///< Number of samples
} ELEM_GETEXPORTNORM_INPUT;
/**
****************************************************************************************************
* ElemGetExportNorm
*
* @brief
* Helper function to check one format can be EXPORT_NUM, which is a register
* CB_COLOR_INFO.SURFACE_FORMAT. FP16 can be reported as EXPORT_NORM for rv770 in r600
* family
* @note
* The implementation is only for r600.
* 00 - EXPORT_FULL: PS exports are 4 pixels with 4 components with 32-bits-per-component. (two
* clocks per export)
* 01 - EXPORT_NORM: PS exports are 4 pixels with 4 components with 16-bits-per-component. (one
* clock per export)
*
****************************************************************************************************
*/
BOOL_32 ADDR_API ElemGetExportNorm(
ADDR_HANDLE hLib,
const ELEM_GETEXPORTNORM_INPUT* pIn);
/**
****************************************************************************************************
* ELEM_FLT32TODEPTHPIXEL_INPUT
*
* @brief
* Input structure for addrFlt32ToDepthPixel
*
****************************************************************************************************
*/
typedef struct _ELEM_FLT32TODEPTHPIXEL_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrDepthFormat format; ///< Depth buffer format
ADDR_FLT_32 comps[2]; ///< Component values (Z/stencil)
} ELEM_FLT32TODEPTHPIXEL_INPUT;
/**
****************************************************************************************************
* ELEM_FLT32TODEPTHPIXEL_INPUT
*
* @brief
* Output structure for ElemFlt32ToDepthPixel
*
****************************************************************************************************
*/
typedef struct _ELEM_FLT32TODEPTHPIXEL_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_8* pPixel; ///< Real depth value. Same data type as depth buffer.
/// Client must provide enough storage for this type.
UINT_32 depthBase; ///< Tile base in bits for depth bits
UINT_32 stencilBase; ///< Tile base in bits for stencil bits
UINT_32 depthBits; ///< Bits for depth
UINT_32 stencilBits; ///< Bits for stencil
} ELEM_FLT32TODEPTHPIXEL_OUTPUT;
/**
****************************************************************************************************
* ElemFlt32ToDepthPixel
*
* @brief
* Convert a FLT_32 value to a depth/stencil pixel value
*
* @return
* Return code
*
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel(
ADDR_HANDLE hLib,
const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn,
ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut);
/**
****************************************************************************************************
* ELEM_FLT32TOCOLORPIXEL_INPUT
*
* @brief
* Input structure for addrFlt32ToColorPixel
*
****************************************************************************************************
*/
typedef struct _ELEM_FLT32TOCOLORPIXEL_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrColorFormat format; ///< Color buffer format
AddrSurfaceNumber surfNum; ///< Surface number
AddrSurfaceSwap surfSwap; ///< Surface swap
ADDR_FLT_32 comps[4]; ///< Component values (r/g/b/a)
} ELEM_FLT32TOCOLORPIXEL_INPUT;
/**
****************************************************************************************************
* ELEM_FLT32TOCOLORPIXEL_INPUT
*
* @brief
* Output structure for ElemFlt32ToColorPixel
*
****************************************************************************************************
*/
typedef struct _ELEM_FLT32TOCOLORPIXEL_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_8* pPixel; ///< Real color value. Same data type as color buffer.
/// Client must provide enough storage for this type.
} ELEM_FLT32TOCOLORPIXEL_OUTPUT;
/**
****************************************************************************************************
* ElemFlt32ToColorPixel
*
* @brief
* Convert a FLT_32 value to a red/green/blue/alpha pixel value
*
* @return
* Return code
*
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel(
ADDR_HANDLE hLib,
const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn,
ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_CONVERT_TILEINFOTOHW_INPUT
*
* @brief
* Input structure for AddrConvertTileInfoToHW
* @note
* When reverse is TRUE, indices are igonred
****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINFOTOHW_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
BOOL_32 reverse; ///< Convert control flag.
/// FALSE: convert from real value to HW value;
/// TRUE: convert from HW value to real value.
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< Tile parameters with real value
INT_32 tileIndex; ///< Tile index, MUST be -1 if you don't want to use it
/// while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
UINT_32 bpp; ///< Bits per pixel
} ADDR_CONVERT_TILEINFOTOHW_INPUT;
/**
****************************************************************************************************
* ADDR_CONVERT_TILEINFOTOHW_OUTPUT
*
* @brief
* Output structure for AddrConvertTileInfoToHW
****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINFOTOHW_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
/// r800 and later HWL parameters
ADDR_TILEINFO* pTileInfo; ///< Tile parameters with hardware register value
} ADDR_CONVERT_TILEINFOTOHW_OUTPUT;
/**
****************************************************************************************************
* AddrConvertTileInfoToHW
*
* @brief
* Convert tile info from real value to hardware register value
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW(
ADDR_HANDLE hLib,
const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn,
ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_CONVERT_TILEINDEX_INPUT
*
* @brief
* Input structure for AddrConvertTileIndex
****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINDEX_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
INT_32 tileIndex; ///< Tile index
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
UINT_32 bpp; ///< Bits per pixel
BOOL_32 tileInfoHw; ///< Set to TRUE if client wants HW enum, otherwise actual
} ADDR_CONVERT_TILEINDEX_INPUT;
/**
****************************************************************************************************
* ADDR_CONVERT_TILEINDEX_OUTPUT
*
* @brief
* Output structure for AddrConvertTileIndex
****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINDEX_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrTileMode tileMode; ///< Tile mode
AddrTileType tileType; ///< Tile type
ADDR_TILEINFO* pTileInfo; ///< Tile info
} ADDR_CONVERT_TILEINDEX_OUTPUT;
/**
****************************************************************************************************
* AddrConvertTileIndex
*
* @brief
* Convert tile index to tile mode/type/info
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex(
ADDR_HANDLE hLib,
const ADDR_CONVERT_TILEINDEX_INPUT* pIn,
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_GET_MACROMODEINDEX_INPUT
*
* @brief
* Input structure for AddrGetMacroModeIndex
****************************************************************************************************
*/
typedef struct _ADDR_GET_MACROMODEINDEX_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR_SURFACE_FLAGS flags; ///< Surface flag
INT_32 tileIndex; ///< Tile index
UINT_32 bpp; ///< Bits per pixel
UINT_32 numFrags; ///< Number of color fragments
} ADDR_GET_MACROMODEINDEX_INPUT;
/**
****************************************************************************************************
* ADDR_GET_MACROMODEINDEX_OUTPUT
*
* @brief
* Output structure for AddrGetMacroModeIndex
****************************************************************************************************
*/
typedef struct _ADDR_GET_MACROMODEINDEX_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
} ADDR_GET_MACROMODEINDEX_OUTPUT;
/**
****************************************************************************************************
* AddrGetMacroModeIndex
*
* @brief
* Get macro mode index based on input parameters
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetMacroModeIndex(
ADDR_HANDLE hLib,
const ADDR_GET_MACROMODEINDEX_INPUT* pIn,
ADDR_GET_MACROMODEINDEX_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_CONVERT_TILEINDEX1_INPUT
*
* @brief
* Input structure for AddrConvertTileIndex1 (without macro mode index)
****************************************************************************************************
*/
typedef struct _ADDR_CONVERT_TILEINDEX1_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
INT_32 tileIndex; ///< Tile index
UINT_32 bpp; ///< Bits per pixel
UINT_32 numSamples; ///< Number of samples
BOOL_32 tileInfoHw; ///< Set to TRUE if client wants HW enum, otherwise actual
} ADDR_CONVERT_TILEINDEX1_INPUT;
/**
****************************************************************************************************
* AddrConvertTileIndex1
*
* @brief
* Convert tile index to tile mode/type/info
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1(
ADDR_HANDLE hLib,
const ADDR_CONVERT_TILEINDEX1_INPUT* pIn,
ADDR_CONVERT_TILEINDEX_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_GET_TILEINDEX_INPUT
*
* @brief
* Input structure for AddrGetTileIndex
****************************************************************************************************
*/
typedef struct _ADDR_GET_TILEINDEX_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrTileMode tileMode; ///< Tile mode
AddrTileType tileType; ///< Tile-type: disp/non-disp/...
ADDR_TILEINFO* pTileInfo; ///< Pointer to tile-info structure, can be NULL for linear/1D
} ADDR_GET_TILEINDEX_INPUT;
/**
****************************************************************************************************
* ADDR_GET_TILEINDEX_OUTPUT
*
* @brief
* Output structure for AddrGetTileIndex
****************************************************************************************************
*/
typedef struct _ADDR_GET_TILEINDEX_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
INT_32 index; ///< index in table
} ADDR_GET_TILEINDEX_OUTPUT;
/**
****************************************************************************************************
* AddrGetTileIndex
*
* @brief
* Get the tiling mode index in table
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex(
ADDR_HANDLE hLib,
const ADDR_GET_TILEINDEX_INPUT* pIn,
ADDR_GET_TILEINDEX_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR_PRT_INFO_INPUT
*
* @brief
* Input structure for AddrComputePrtInfo
****************************************************************************************************
*/
typedef struct _ADDR_PRT_INFO_INPUT
{
AddrFormat format; ///< Surface format
UINT_32 baseMipWidth; ///< Base mipmap width
UINT_32 baseMipHeight; ///< Base mipmap height
UINT_32 baseMipDepth; ///< Base mipmap depth
UINT_32 numFrags; ///< Number of fragments,
} ADDR_PRT_INFO_INPUT;
/**
****************************************************************************************************
* ADDR_PRT_INFO_OUTPUT
*
* @brief
* Input structure for AddrComputePrtInfo
****************************************************************************************************
*/
typedef struct _ADDR_PRT_INFO_OUTPUT
{
UINT_32 prtTileWidth;
UINT_32 prtTileHeight;
} ADDR_PRT_INFO_OUTPUT;
/**
****************************************************************************************************
* AddrComputePrtInfo
*
* @brief
* Compute prt surface related information
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo(
ADDR_HANDLE hLib,
const ADDR_PRT_INFO_INPUT* pIn,
ADDR_PRT_INFO_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// DCC key functions
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* _ADDR_COMPUTE_DCCINFO_INPUT
*
* @brief
* Input structure of AddrComputeDccInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_DCCINFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 bpp; ///< BitPP of color surface
UINT_32 numSamples; ///< Sample number of color surface
UINT_64 colorSurfSize; ///< Size of color surface to which dcc key is bound
AddrTileMode tileMode; ///< Tile mode of color surface
ADDR_TILEINFO tileInfo; ///< Tile info of color surface
UINT_32 tileSwizzle; ///< Tile swizzle
INT_32 tileIndex; ///< Tile index of color surface,
///< MUST be -1 if you don't want to use it
///< while the global useTileIndex is set to 1
INT_32 macroModeIndex; ///< Index in macro tile mode table if there is one (CI)
///< README: When tileIndex is not -1, this must be valid
} ADDR_COMPUTE_DCCINFO_INPUT;
/**
****************************************************************************************************
* ADDR_COMPUTE_DCCINFO_OUTPUT
*
* @brief
* Output structure of AddrComputeDccInfo
****************************************************************************************************
*/
typedef struct _ADDR_COMPUTE_DCCINFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 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_ALIGNMENTS_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 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);
/**
****************************************************************************************************
* 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 reserved : 17; ///< Reserved bits
};
UINT_32 value;
} ADDR2_SURFACE_FLAGS;
/**
****************************************************************************************************
* ADDR2_COMPUTE_SURFACE_INFO_INPUT
*
* @brief
* Input structure for Addr2ComputeSurfaceInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SURFACE_INFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR2_SURFACE_FLAGS flags; ///< Surface flags
AddrSwizzleMode swizzleMode; ///< Swizzle Mode for Gfx9
AddrResourceType resourceType; ///< Surface type
AddrFormat format; ///< Surface format
UINT_32 bpp; ///< bits per pixel
UINT_32 width; ///< Width (of mip0), in pixels
UINT_32 height; ///< Height (of mip0), in pixels
UINT_32 numSlices; ///< Number surface slice/depth (of mip0),
UINT_32 numMipLevels; ///< Total mipmap levels.
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
UINT_32 pitchInElement; ///< Pitch in elements (blocks for compressed formats)
UINT_32 sliceAlign; ///< Required slice size in bytes
} ADDR2_COMPUTE_SURFACE_INFO_INPUT;
/**
****************************************************************************************************
* ADDR2_MIP_INFO
*
* @brief
* Structure that contains information for mip level
*
****************************************************************************************************
*/
typedef struct _ADDR2_MIP_INFO
{
UINT_32 pitch; ///< Pitch in elements
UINT_32 height; ///< Padded height in elements
UINT_32 depth; ///< Padded depth
UINT_32 pixelPitch; ///< Pitch in pixels
UINT_32 pixelHeight; ///< Padded height in pixels
UINT_32 equationIndex; ///< Equation index in the equation table
UINT_64 offset; ///< Offset in bytes from mip base, should only be used
///< to setup vam surface descriptor, can't be used
///< to setup swizzle pattern
UINT_64 macroBlockOffset; ///< macro block offset in bytes from mip base
UINT_32 mipTailOffset; ///< mip tail offset in bytes
UINT_32 mipTailCoordX; ///< mip tail coord x
UINT_32 mipTailCoordY; ///< mip tail coord y
UINT_32 mipTailCoordZ; ///< mip tail coord z
} ADDR2_MIP_INFO;
/**
****************************************************************************************************
* ADDR2_COMPUTE_SURFACE_INFO_OUTPUT
*
* @brief
* Output structure for Addr2ComputeSurfInfo
* @note
Element: AddrLib unit for computing. e.g. BCn: 4x4 blocks; R32B32B32: 32bit with 3x pitch
Pixel: Original pixel
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SURFACE_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch in elements (blocks for compressed formats)
UINT_32 height; ///< Padded height (of mip0) in elements
UINT_32 numSlices; ///< Padded depth for 3d resource
///< or padded number of slices for 2d array resource
UINT_32 mipChainPitch; ///< Pitch (of total mip chain) in elements
UINT_32 mipChainHeight; ///< Padded height (of total mip chain) in elements
UINT_32 mipChainSlice; ///< Padded depth (of total mip chain)
UINT_64 sliceSize; ///< Slice (total mip chain) size in bytes
UINT_64 surfSize; ///< Surface (total mip chain) size in bytes
UINT_32 baseAlign; ///< Base address alignment
UINT_32 bpp; ///< Bits per elements
/// (e.g. blocks for BCn, 1/3 for 96bit)
UINT_32 pixelMipChainPitch; ///< Mip chain pitch in original pixels
UINT_32 pixelMipChainHeight; ///< Mip chain height in original pixels
UINT_32 pixelPitch; ///< Pitch in original pixels
UINT_32 pixelHeight; ///< Height in original pixels
UINT_32 pixelBits; ///< Original bits per pixel, passed from input
UINT_32 blockWidth; ///< Width in element inside one block
UINT_32 blockHeight; ///< Height in element inside one block
UINT_32 blockSlices; ///< Slice number inside one block
///< Prt tile is one block, its width/height/slice
///< equals to blcok width/height/slice
BOOL_32 epitchIsHeight; ///< Whether to use height to program epitch register
/// Stereo info
ADDR_QBSTEREOINFO* pStereoInfo; ///< Stereo info, needed if qbStereo flag is TRUE
/// Mip info
ADDR2_MIP_INFO* pMipInfo; ///< Pointer to mip information array
/// if it is not NULL, the array is assumed to
/// contain numMipLevels entries
UINT_32 equationIndex; ///< Equation index in the equation table of mip0
BOOL_32 mipChainInTail; ///< If whole mipchain falls into mip tail block
UINT_32 firstMipIdInTail; ///< The id of first mip in tail, if there is no mip
/// in tail, it will be set to number of mip levels
} ADDR2_COMPUTE_SURFACE_INFO_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeSurfaceInfo
*
* @brief
* Compute surface width/height/slices/alignments and suitable tiling mode
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceInfo(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn,
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for Addr2ComputeSurfaceAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
UINT_32 sample; ///< Sample index, use fragment index for EQAA
UINT_32 mipId; ///< the mip ID in mip chain
AddrSwizzleMode swizzleMode; ///< Swizzle mode for Gfx9
ADDR2_SURFACE_FLAGS flags; ///< Surface flags
AddrResourceType resourceType; ///< Surface type
UINT_32 bpp; ///< Bits per pixel
UINT_32 unalignedWidth; ///< Surface original width (of mip0)
UINT_32 unalignedHeight; ///< Surface original height (of mip0)
UINT_32 numSlices; ///< Surface original slices (of mip0)
UINT_32 numMipLevels; ///< Total mipmap levels
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
UINT_32 pipeBankXor; ///< Combined swizzle used to do bank/pipe rotation
UINT_32 pitchInElement; ///< Pitch in elements (blocks for compressed formats)
} ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for Addr2ComputeSurfaceAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Byte address
UINT_32 bitPosition; ///< Bit position within surfaceAddr, 0-7.
/// For surface bpp < 8, e.g. FMT_1.
UINT_32 prtBlockIndex; ///< Index of a PRT tile (64K block)
} ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeSurfaceAddrFromCoord
*
* @brief
* Compute surface address from a given coordinate.
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn,
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT
*
* @brief
* Input structure for Addr2ComputeSurfaceCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address in bytes
UINT_32 bitPosition; ///< Bit position in addr. 0-7. for surface bpp < 8,
/// e.g. FMT_1;
AddrSwizzleMode swizzleMode; ///< Swizzle mode for Gfx9
ADDR2_SURFACE_FLAGS flags; ///< Surface flags
AddrResourceType resourceType; ///< Surface type
UINT_32 bpp; ///< Bits per pixel
UINT_32 unalignedWidth; ///< Surface original width (of mip0)
UINT_32 unalignedHeight; ///< Surface original height (of mip0)
UINT_32 numSlices; ///< Surface original slices (of mip0)
UINT_32 numMipLevels; ///< Total mipmap levels.
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
UINT_32 pipeBankXor; ///< Combined swizzle used to do bank/pipe rotation
UINT_32 pitchInElement; ///< Pitch in elements (blocks for compressed formats)
} ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for Addr2ComputeSurfaceCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slices
UINT_32 sample; ///< Index of samples, means fragment index for EQAA
UINT_32 mipId; ///< mipmap level id
} ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeSurfaceCoordFromAddr
*
* @brief
* Compute coordinate from a given surface address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSurfaceCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn,
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// HTile functions for Gfx9
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR2_META_FLAGS
*
* @brief
* Metadata flags
****************************************************************************************************
*/
typedef union _ADDR2_META_FLAGS
{
struct
{
UINT_32 pipeAligned : 1; ///< if Metadata being pipe aligned
UINT_32 rbAligned : 1; ///< if Metadata being RB aligned
UINT_32 linear : 1; ///< if Metadata linear, GFX9 does not suppord this!
UINT_32 reserved : 29; ///< Reserved bits
};
UINT_32 value;
} ADDR2_META_FLAGS;
/**
****************************************************************************************************
* ADDR2_META_MIP_INFO
*
* @brief
* Structure to store per mip metadata information
****************************************************************************************************
*/
typedef struct _ADDR2_META_MIP_INFO
{
BOOL_32 inMiptail;
union
{
struct
{
UINT_32 startX;
UINT_32 startY;
UINT_32 startZ;
UINT_32 width;
UINT_32 height;
UINT_32 depth;
};
struct
{
UINT_32 offset;
UINT_32 sliceSize;
};
};
} ADDR2_META_MIP_INFO;
/**
****************************************************************************************************
* ADDR2_COMPUTE_HTILE_INFO_INPUT
*
* @brief
* Input structure of Addr2ComputeHtileInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_HTILE_INFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR2_META_FLAGS hTileFlags; ///< HTILE flags
ADDR2_SURFACE_FLAGS depthFlags; ///< Depth surface flags
AddrSwizzleMode swizzleMode; ///< Depth surface swizzle mode
UINT_32 unalignedWidth; ///< Depth surface original width (of mip0)
UINT_32 unalignedHeight; ///< Depth surface original height (of mip0)
UINT_32 numSlices; ///< Number of slices of depth surface (of mip0)
UINT_32 numMipLevels; ///< Total mipmap levels of color surface
UINT_32 firstMipIdInTail;
} ADDR2_COMPUTE_HTILE_INFO_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_HTILE_INFO_OUTPUT
*
* @brief
* Output structure of Addr2ComputeHtileInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_HTILE_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch in pixels of depth buffer represented in this
/// HTile buffer. This might be larger than original depth
/// buffer pitch when called with an unaligned pitch.
UINT_32 height; ///< Height in pixels, as above
UINT_32 baseAlign; ///< Base alignment
UINT_32 sliceSize; ///< Slice size, in bytes.
UINT_32 htileBytes; ///< Size of HTILE buffer, in bytes
UINT_32 metaBlkWidth; ///< Meta block width
UINT_32 metaBlkHeight; ///< Meta block height
UINT_32 metaBlkNumPerSlice; ///< Number of metablock within one slice
ADDR2_META_MIP_INFO* pMipInfo; ///< HTILE mip information
} ADDR2_COMPUTE_HTILE_INFO_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeHtileInfo
*
* @brief
* Compute Htile pitch, height, base alignment and size in bytes
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileInfo(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn,
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for Addr2ComputeHtileAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slices
UINT_32 mipId; ///< mipmap level id
ADDR2_META_FLAGS hTileFlags; ///< HTILE flags
ADDR2_SURFACE_FLAGS depthflags; ///< Depth surface flags
AddrSwizzleMode swizzleMode; ///< Depth surface swizzle mode
UINT_32 bpp; ///< Depth surface bits per pixel
UINT_32 unalignedWidth; ///< Depth surface original width (of mip0)
UINT_32 unalignedHeight; ///< Depth surface original height (of mip0)
UINT_32 numSlices; ///< Depth surface original depth (of mip0)
UINT_32 numMipLevels; ///< Depth surface total mipmap levels
UINT_32 numSamples; ///< Depth surface number of samples
UINT_32 pipeXor; ///< Pipe xor setting
} ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for Addr2ComputeHtileAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address in bytes
} ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeHtileAddrFromCoord
*
* @brief
* Compute Htile address according to coordinates (of depth buffer)
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn,
ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT
*
* @brief
* Input structure for Addr2ComputeHtileCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address
ADDR2_META_FLAGS hTileFlags; ///< HTILE flags
ADDR2_SURFACE_FLAGS depthFlags; ///< Depth surface flags
AddrSwizzleMode swizzleMode; ///< Depth surface swizzle mode
UINT_32 bpp; ///< Depth surface bits per pixel
UINT_32 unalignedWidth; ///< Depth surface original width (of mip0)
UINT_32 unalignedHeight; ///< Depth surface original height (of mip0)
UINT_32 numSlices; ///< Depth surface original depth (of mip0)
UINT_32 numMipLevels; ///< Depth surface total mipmap levels
UINT_32 numSamples; ///< Depth surface number of samples
UINT_32 pipeXor; ///< Pipe xor setting
} ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for Addr2ComputeHtileCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slices
UINT_32 mipId; ///< mipmap level id
} ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeHtileCoordFromAddr
*
* @brief
* Compute coordinates within depth buffer (1st pixel of a micro tile) according to
* Htile address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeHtileCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn,
ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// C-mask functions for Gfx9
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR2_COMPUTE_CMASK_INFO_INPUT
*
* @brief
* Input structure of Addr2ComputeCmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_CMASKINFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR2_META_FLAGS cMaskFlags; ///< CMASK flags
ADDR2_SURFACE_FLAGS colorFlags; ///< Color surface flags
AddrResourceType resourceType; ///< Color surface type
AddrSwizzleMode swizzleMode; ///< FMask surface swizzle mode
UINT_32 unalignedWidth; ///< Color surface original width
UINT_32 unalignedHeight; ///< Color surface original height
UINT_32 numSlices; ///< Number of slices of color buffer
} ADDR2_COMPUTE_CMASK_INFO_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_CMASK_INFO_OUTPUT
*
* @brief
* Output structure of Addr2ComputeCmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_CMASK_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch in pixels of color buffer which
/// this Cmask matches. The size might be larger than
/// original color buffer pitch when called with
/// an unaligned pitch.
UINT_32 height; ///< Height in pixels, as above
UINT_32 baseAlign; ///< Base alignment
UINT_32 sliceSize; ///< Slice size, in bytes.
UINT_32 cmaskBytes; ///< Size in bytes of CMask buffer
UINT_32 metaBlkWidth; ///< Meta block width
UINT_32 metaBlkHeight; ///< Meta block height
UINT_32 metaBlkNumPerSlice; ///< Number of metablock within one slice
} ADDR2_COMPUTE_CMASK_INFO_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeCmaskInfo
*
* @brief
* Compute Cmask pitch, height, base alignment and size in bytes from color buffer
* info
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskInfo(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn,
ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for Addr2ComputeCmaskAddrFromCoord
*
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slices
ADDR2_META_FLAGS cMaskFlags; ///< CMASK flags
ADDR2_SURFACE_FLAGS colorFlags; ///< Color surface flags
AddrResourceType resourceType; ///< Color surface type
AddrSwizzleMode swizzleMode; ///< FMask surface swizzle mode
UINT_32 unalignedWidth; ///< Color surface original width (of mip0)
UINT_32 unalignedHeight; ///< Color surface original height (of mip0)
UINT_32 numSlices; ///< Color surface original slices (of mip0)
UINT_32 numSamples; ///< Color surfae sample number
UINT_32 numFrags; ///< Color surface fragment number
UINT_32 pipeXor; ///< pipe Xor setting
} ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for Addr2ComputeCmaskAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< CMASK address in bytes
UINT_32 bitPosition; ///< Bit position within addr, 0 or 4
} ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeCmaskAddrFromCoord
*
* @brief
* Compute Cmask address according to coordinates (of MSAA color buffer)
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn,
ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT
*
* @brief
* Input structure for Addr2ComputeCmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< CMASK address in bytes
UINT_32 bitPosition; ///< Bit position within addr, 0 or 4
ADDR2_META_FLAGS cMaskFlags; ///< CMASK flags
ADDR2_SURFACE_FLAGS colorFlags; ///< Color surface flags
AddrResourceType resourceType; ///< Color surface type
AddrSwizzleMode swizzleMode; ///< FMask surface swizzle mode
UINT_32 unalignedWidth; ///< Color surface original width (of mip0)
UINT_32 unalignedHeight; ///< Color surface original height (of mip0)
UINT_32 numSlices; ///< Color surface original slices (of mip0)
UINT_32 numMipLevels; ///< Color surface total mipmap levels.
} ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for Addr2ComputeCmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slices
UINT_32 mipId; ///< mipmap level id
} ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeCmaskCoordFromAddr
*
* @brief
* Compute coordinates within color buffer (1st pixel of a micro tile) according to
* Cmask address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeCmaskCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn,
ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// F-mask functions for Gfx9
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR2_FMASK_FLAGS
*
* @brief
* FMASK flags
****************************************************************************************************
*/
typedef union _ADDR2_FMASK_FLAGS
{
struct
{
UINT_32 resolved : 1; ///< TRUE if this is a resolved fmask, used by H/W clients
/// by H/W clients. S/W should always set it to FALSE.
UINT_32 reserved : 31; ///< Reserved for future use.
};
UINT_32 value;
} ADDR2_FMASK_FLAGS;
/**
****************************************************************************************************
* ADDR2_COMPUTE_FMASK_INFO_INPUT
*
* @brief
* Input structure for Addr2ComputeFmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_FMASK_INFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrSwizzleMode swizzleMode; ///< FMask surface swizzle mode
UINT_32 unalignedWidth; ///< Color surface original width
UINT_32 unalignedHeight; ///< Color surface original height
UINT_32 numSlices; ///< Number of slices/depth
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
ADDR2_FMASK_FLAGS fMaskFlags; ///< FMASK flags
} ADDR2_COMPUTE_FMASK_INFO_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_FMASK_INFO_OUTPUT
*
* @brief
* Output structure for Addr2ComputeFmaskInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_FMASK_INFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pitch; ///< Pitch of fmask in pixels
UINT_32 height; ///< Height of fmask in pixels
UINT_32 baseAlign; ///< Base alignment
UINT_32 numSlices; ///< Slices of fmask
UINT_32 fmaskBytes; ///< Size of fmask in bytes
UINT_32 bpp; ///< Bits per pixel of FMASK is: number of bit planes
UINT_32 numSamples; ///< Number of samples
UINT_32 sliceSize; ///< Size of slice in bytes
} ADDR2_COMPUTE_FMASK_INFO_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeFmaskInfo
*
* @brief
* Compute Fmask pitch/height/slices/alignments and size in bytes
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskInfo(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn,
ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for Addr2ComputeFmaskAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrSwizzleMode swizzleMode; ///< FMask surface swizzle mode
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
UINT_32 sample; ///< Sample index (fragment index for EQAA)
UINT_32 plane; ///< Plane number
UINT_32 unalignedWidth; ///< Color surface original width
UINT_32 unalignedHeight; ///< Color surface original height
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
UINT_32 tileSwizzle; ///< Combined swizzle used to do bank/pipe rotation
ADDR2_FMASK_FLAGS fMaskFlags; ///< FMASK flags
} ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for Addr2ComputeFmaskAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Fmask address
UINT_32 bitPosition; ///< Bit position within fmaskAddr, 0-7.
} ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeFmaskAddrFromCoord
*
* @brief
* Compute Fmask address according to coordinates (x,y,slice,sample,plane)
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn,
ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT
*
* @brief
* Input structure for Addr2ComputeFmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< Address
UINT_32 bitPosition; ///< Bit position within addr, 0-7.
AddrSwizzleMode swizzleMode; ///< FMask surface swizzle mode
UINT_32 unalignedWidth; ///< Color surface original width
UINT_32 unalignedHeight; ///< Color surface original height
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments
UINT_32 tileSwizzle; ///< Combined swizzle used to do bank/pipe rotation
ADDR2_FMASK_FLAGS fMaskFlags; ///< FMASK flags
} ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
*
* @brief
* Output structure for Addr2ComputeFmaskCoordFromAddr
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Slice index
UINT_32 sample; ///< Sample index (fragment index for EQAA)
UINT_32 plane; ///< Plane number
} ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeFmaskCoordFromAddr
*
* @brief
* Compute FMASK coordinate from an given address
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeFmaskCoordFromAddr(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn,
ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// DCC key functions for Gfx9
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* _ADDR2_COMPUTE_DCCINFO_INPUT
*
* @brief
* Input structure of Addr2ComputeDccInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_DCCINFO_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR2_META_FLAGS dccKeyFlags; ///< DCC key flags
ADDR2_SURFACE_FLAGS colorFlags; ///< Color surface flags
AddrResourceType resourceType; ///< Color surface type
AddrSwizzleMode swizzleMode; ///< Color surface swizzle mode
UINT_32 bpp; ///< bits per pixel
UINT_32 unalignedWidth; ///< Color surface original width (of mip0)
UINT_32 unalignedHeight; ///< Color surface original height (of mip0)
UINT_32 numSlices; ///< Number of slices, of color surface (of mip0)
UINT_32 numFrags; ///< Fragment number of color surface
UINT_32 numMipLevels; ///< Total mipmap levels of color surface
UINT_32 dataSurfaceSize; ///< The padded size of all slices and mip levels
///< useful in meta linear case
UINT_32 firstMipIdInTail;
} ADDR2_COMPUTE_DCCINFO_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_DCCINFO_OUTPUT
*
* @brief
* Output structure of Addr2ComputeDccInfo
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_DCCINFO_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 dccRamBaseAlign; ///< Base alignment of dcc key
UINT_32 dccRamSize; ///< Size of dcc key
UINT_32 pitch; ///< DCC surface mip chain pitch
UINT_32 height; ///< DCC surface mip chain height
UINT_32 depth; ///< DCC surface mip chain depth
UINT_32 compressBlkWidth; ///< DCC compress block width
UINT_32 compressBlkHeight; ///< DCC compress block height
UINT_32 compressBlkDepth; ///< DCC compress block depth
UINT_32 metaBlkWidth; ///< DCC meta block width
UINT_32 metaBlkHeight; ///< DCC meta block height
UINT_32 metaBlkDepth; ///< DCC meta block depth
UINT_32 metaBlkNumPerSlice; ///< Number of metablock within one slice
union
{
UINT_32 fastClearSizePerSlice; ///< Size of DCC within a slice should be fast cleared
UINT_32 dccRamSliceSize;
};
ADDR2_META_MIP_INFO* pMipInfo; ///< DCC mip information
} ADDR2_COMPUTE_DCCINFO_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeDccInfo
*
* @brief
* Compute DCC key size, base alignment
* info
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccInfo(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn,
ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
*
* @brief
* Input structure for Addr2ComputeDccAddrFromCoord
*
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 x; ///< X coordinate
UINT_32 y; ///< Y coordinate
UINT_32 slice; ///< Index of slices
UINT_32 sample; ///< Index of samples, means fragment index for EQAA
UINT_32 mipId; ///< mipmap level id
ADDR2_META_FLAGS dccKeyFlags; ///< DCC flags
ADDR2_SURFACE_FLAGS colorFlags; ///< Color surface flags
AddrResourceType resourceType; ///< Color surface type
AddrSwizzleMode swizzleMode; ///< Color surface swizzle mode
UINT_32 bpp; ///< Color surface bits per pixel
UINT_32 unalignedWidth; ///< Color surface original width (of mip0)
UINT_32 unalignedHeight; ///< Color surface original height (of mip0)
UINT_32 numSlices; ///< Color surface original slices (of mip0)
UINT_32 numMipLevels; ///< Color surface mipmap levels
UINT_32 numFrags; ///< Color surface fragment number
UINT_32 pipeXor; ///< pipe Xor setting
} ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
*
* @brief
* Output structure for Addr2ComputeDccAddrFromCoord
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 addr; ///< DCC address in bytes
} ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeDccAddrFromCoord
*
* @brief
* Compute DCC address according to coordinates (of MSAA color buffer)
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeDccAddrFromCoord(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn,
ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut);
////////////////////////////////////////////////////////////////////////////////////////////////////
// Misc functions for Gfx9
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
****************************************************************************************************
* ADDR2_COMPUTE_PIPEBANKXOR_INPUT
*
* @brief
* Input structure of Addr2ComputePipebankXor
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_PIPEBANKXOR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 surfIndex; ///< Input surface index
ADDR2_SURFACE_FLAGS flags; ///< Surface flag
AddrSwizzleMode swizzleMode; ///< Surface swizzle mode
AddrResourceType resourceType; ///< Surface resource type
AddrFormat format; ///< Surface format
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
} ADDR2_COMPUTE_PIPEBANKXOR_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT
*
* @brief
* Output structure of Addr2ComputePipebankXor
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pipeBankXor; ///< Pipe bank xor
} ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputePipeBankXor
*
* @brief
* Calculate a valid bank pipe xor value for client to use.
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputePipeBankXor(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
*
* @brief
* Input structure of Addr2ComputeSlicePipeBankXor
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrSwizzleMode swizzleMode; ///< Surface swizzle mode
AddrResourceType resourceType; ///< Surface resource type
UINT_32 basePipeBankXor; ///< Base pipe bank xor
UINT_32 slice; ///< Slice id
UINT_32 numSamples; ///< Number of samples
} ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
*
* @brief
* Output structure of Addr2ComputeSlicePipeBankXor
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_32 pipeBankXor; ///< Pipe bank xor
} ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeSlicePipeBankXor
*
* @brief
* Calculate slice pipe bank xor value based on base pipe bank xor and slice id.
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSlicePipeBankXor(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
*
* @brief
* Input structure of Addr2ComputeSubResourceOffsetForSwizzlePattern
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrSwizzleMode swizzleMode; ///< Surface swizzle mode
AddrResourceType resourceType; ///< Surface resource type
UINT_32 pipeBankXor; ///< Per resource xor
UINT_32 slice; ///< Slice id
UINT_64 sliceSize; ///< Slice size of a mip chain
UINT_64 macroBlockOffset; ///< Macro block offset, returned in ADDR2_MIP_INFO
UINT_32 mipTailOffset; ///< Mip tail offset, returned in ADDR2_MIP_INFO
} ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT;
/**
****************************************************************************************************
* ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
*
* @brief
* Output structure of Addr2ComputeSubResourceOffsetForSwizzlePattern
****************************************************************************************************
*/
typedef struct _ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
UINT_64 offset; ///< offset
} ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT;
/**
****************************************************************************************************
* Addr2ComputeSubResourceOffsetForSwizzlePattern
*
* @brief
* Calculate sub resource offset to support swizzle pattern.
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2ComputeSubResourceOffsetForSwizzlePattern(
ADDR_HANDLE hLib,
const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut);
/**
****************************************************************************************************
* ADDR2_BLOCK_SET
*
* @brief
* Bit field that defines block type
****************************************************************************************************
*/
typedef union _ADDR2_BLOCK_SET
{
struct
{
UINT_32 micro : 1; // 256B block for 2D resource
UINT_32 macro4KB : 1; // 4KB for 2D/3D resource
UINT_32 macro64KB : 1; // 64KB for 2D/3D resource
UINT_32 var : 1; // VAR block
UINT_32 linear : 1; // Linear block
UINT_32 reserved : 27;
};
UINT_32 value;
} ADDR2_BLOCK_SET;
/**
****************************************************************************************************
* ADDR2_SWTYPE_SET
*
* @brief
* Bit field that defines swizzle type
****************************************************************************************************
*/
typedef union _ADDR2_SWTYPE_SET
{
struct
{
UINT_32 sw_Z : 1; // SW_*_Z_*
UINT_32 sw_S : 1; // SW_*_S_*
UINT_32 sw_D : 1; // SW_*_D_*
UINT_32 sw_R : 1; // SW_*_R_*
UINT_32 reserved : 28;
};
UINT_32 value;
} ADDR2_SWTYPE_SET;
/**
****************************************************************************************************
* ADDR2_GET_PREFERRED_SURF_SETTING_INPUT
*
* @brief
* Input structure of Addr2GetPreferredSurfaceSetting
****************************************************************************************************
*/
typedef struct _ADDR2_GET_PREFERRED_SURF_SETTING_INPUT
{
UINT_32 size; ///< Size of this structure in bytes
ADDR2_SURFACE_FLAGS flags; ///< Surface flags
AddrResourceType resourceType; ///< Surface type
AddrFormat format; ///< Surface format
AddrResrouceLocation resourceLoction; ///< Surface heap choice
ADDR2_BLOCK_SET forbiddenBlock; ///< Client can use it to disable some block setting
///< such as linear for DXTn, tiled for YUV
ADDR2_SWTYPE_SET preferredSwSet; ///< Client can use it to specify sw type(s) wanted
BOOL_32 noXor; ///< Do not use xor mode for this resource
UINT_32 bpp; ///< bits per pixel
UINT_32 width; ///< Width (of mip0), in pixels
UINT_32 height; ///< Height (of mip0), in pixels
UINT_32 numSlices; ///< Number surface slice/depth (of mip0),
UINT_32 numMipLevels; ///< Total mipmap levels.
UINT_32 numSamples; ///< Number of samples
UINT_32 numFrags; ///< Number of fragments, leave it zero or the same as
/// number of samples for normal AA; Set it to the
/// number of fragments for EQAA
UINT_32 maxAlign; ///< maximum base/size alignment requested by client
UINT_32 minSizeAlign; ///< memory allocated for surface in client driver will
/// be padded to multiple of this value (in bytes)
} ADDR2_GET_PREFERRED_SURF_SETTING_INPUT;
/**
****************************************************************************************************
* ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT
*
* @brief
* Output structure of Addr2GetPreferredSurfaceSetting
****************************************************************************************************
*/
typedef struct _ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT
{
UINT_32 size; ///< Size of this structure in bytes
AddrSwizzleMode swizzleMode; ///< Suggested swizzle mode to be used
AddrResourceType resourceType; ///< Suggested resource type to program HW
ADDR2_BLOCK_SET validBlockSet; ///< Valid block type bit conbination
BOOL_32 canXor; ///< If client can use xor on a valid macro block
/// type
ADDR2_SWTYPE_SET validSwTypeSet; ///< Valid swizzle type bit combination
ADDR2_SWTYPE_SET clientPreferredSwSet; ///< Client-preferred swizzle type bit combination
} ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT;
/**
****************************************************************************************************
* Addr2GetPreferredSurfaceSetting
*
* @brief
* Suggest a preferred setting for client driver to program HW register
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2GetPreferredSurfaceSetting(
ADDR_HANDLE hLib,
const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut);
/**
****************************************************************************************************
* Addr2IsValidDisplaySwizzleMode
*
* @brief
* Return whether the swizzle mode is supported by DCE / DCN.
****************************************************************************************************
*/
ADDR_E_RETURNCODE ADDR_API Addr2IsValidDisplaySwizzleMode(
ADDR_HANDLE hLib,
AddrSwizzleMode swizzleMode,
UINT_32 bpp,
bool *result);
#if defined(__cplusplus)
}
#endif
#endif // __ADDR_INTERFACE_H__