/*
|
* 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__
|
