/*
* Copyright © 2017 Advanced Micro Devices, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
* AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
* USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*/
/**
************************************************************************************************************************
* @file addrlib2.cpp
* @brief Contains the implementation for the AddrLib2 base class.
************************************************************************************************************************
*/
#include "addrinterface.h"
#include "addrlib2.h"
#include "addrcommon.h"
namespace Addr
{
namespace V2
{
////////////////////////////////////////////////////////////////////////////////////////////////////
// Static Const Member
////////////////////////////////////////////////////////////////////////////////////////////////////
const Dim2d Lib::Block256_2d[] = {{16, 16}, {16, 8}, {8, 8}, {8, 4}, {4, 4}};
const Dim3d Lib::Block1K_3d[] = {{16, 8, 8}, {8, 8, 8}, {8, 8, 4}, {8, 4, 4}, {4, 4, 4}};
////////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor/Destructor
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
************************************************************************************************************************
* Lib::Lib
*
* @brief
* Constructor for the Addr::V2::Lib class
*
************************************************************************************************************************
*/
Lib::Lib()
:
Addr::Lib()
{
}
/**
************************************************************************************************************************
* Lib::Lib
*
* @brief
* Constructor for the AddrLib2 class with hClient as parameter
*
************************************************************************************************************************
*/
Lib::Lib(const Client* pClient)
:
Addr::Lib(pClient)
{
}
/**
************************************************************************************************************************
* Lib::~Lib
*
* @brief
* Destructor for the AddrLib2 class
*
************************************************************************************************************************
*/
Lib::~Lib()
{
}
/**
************************************************************************************************************************
* Lib::GetLib
*
* @brief
* Get Addr::V2::Lib pointer
*
* @return
* An Addr::V2::Lib class pointer
************************************************************************************************************************
*/
Lib* Lib::GetLib(
ADDR_HANDLE hLib) ///< [in] handle of ADDR_HANDLE
{
Addr::Lib* pAddrLib = Addr::Lib::GetLib(hLib);
if ((pAddrLib != NULL) &&
(pAddrLib->GetChipFamily() <= ADDR_CHIP_FAMILY_VI))
{
// only valid and GFX9+ AISC can use AddrLib2 function.
ADDR_ASSERT_ALWAYS();
hLib = NULL;
}
return static_cast<Lib*>(hLib);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Surface Methods
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
************************************************************************************************************************
* Lib::ComputeSurfaceInfo
*
* @brief
* Interface function stub of AddrComputeSurfaceInfo.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfo(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
if (GetFillSizeFieldsFlags() == TRUE)
{
if ((pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_INFO_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_SURFACE_INFO_OUTPUT)))
{
returnCode = ADDR_PARAMSIZEMISMATCH;
}
}
// Adjust coming parameters.
ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = *pIn;
localIn.width = Max(pIn->width, 1u);
localIn.height = Max(pIn->height, 1u);
localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
localIn.numSlices = Max(pIn->numSlices, 1u);
localIn.numSamples = Max(pIn->numSamples, 1u);
localIn.numFrags = (localIn.numFrags == 0) ? localIn.numSamples : pIn->numFrags;
UINT_32 expandX = 1;
UINT_32 expandY = 1;
ElemMode elemMode = ADDR_UNCOMPRESSED;
if (returnCode == ADDR_OK)
{
// Set format to INVALID will skip this conversion
if (localIn.format != ADDR_FMT_INVALID)
{
// Get compression/expansion factors and element mode which indicates compression/expansion
localIn.bpp = GetElemLib()->GetBitsPerPixel(localIn.format,
&elemMode,
&expandX,
&expandY);
// Special flag for 96 bit surface. 96 (or 48 if we support) bit surface's width is
// pre-multiplied by 3 and bpp is divided by 3. So pitch alignment for linear-
// aligned does not meet 64-pixel in real. We keep special handling in hwl since hw
// restrictions are different.
// Also Mip 1+ needs an element pitch of 32 bits so we do not need this workaround
// but we use this flag to skip RestoreSurfaceInfo below
if ((elemMode == ADDR_EXPANDED) && (expandX > 1))
{
ADDR_ASSERT(IsLinear(localIn.swizzleMode));
}
UINT_32 basePitch = 0;
GetElemLib()->AdjustSurfaceInfo(elemMode,
expandX,
expandY,
&localIn.bpp,
&basePitch,
&localIn.width,
&localIn.height);
// Overwrite these parameters if we have a valid format
}
if (localIn.bpp != 0)
{
localIn.width = Max(localIn.width, 1u);
localIn.height = Max(localIn.height, 1u);
}
else // Rule out some invalid parameters
{
ADDR_ASSERT_ALWAYS();
returnCode = ADDR_INVALIDPARAMS;
}
}
if (returnCode == ADDR_OK)
{
returnCode = ComputeSurfaceInfoSanityCheck(&localIn);
}
if (returnCode == ADDR_OK)
{
VerifyMipLevelInfo(pIn);
if (IsLinear(pIn->swizzleMode))
{
// linear mode
returnCode = ComputeSurfaceInfoLinear(&localIn, pOut);
}
else
{
// tiled mode
returnCode = ComputeSurfaceInfoTiled(&localIn, pOut);
}
if (returnCode == ADDR_OK)
{
pOut->bpp = localIn.bpp;
pOut->pixelPitch = pOut->pitch;
pOut->pixelHeight = pOut->height;
pOut->pixelMipChainPitch = pOut->mipChainPitch;
pOut->pixelMipChainHeight = pOut->mipChainHeight;
pOut->pixelBits = localIn.bpp;
if (localIn.format != ADDR_FMT_INVALID)
{
UINT_32 pixelBits = pOut->pixelBits;
GetElemLib()->RestoreSurfaceInfo(elemMode,
expandX,
expandY,
&pOut->pixelBits,
&pOut->pixelPitch,
&pOut->pixelHeight);
GetElemLib()->RestoreSurfaceInfo(elemMode,
expandX,
expandY,
&pixelBits,
&pOut->pixelMipChainPitch,
&pOut->pixelMipChainHeight);
if ((localIn.numMipLevels > 1) && (pOut->pMipInfo != NULL))
{
for (UINT_32 i = 0; i < localIn.numMipLevels; i++)
{
pOut->pMipInfo[i].pixelPitch = pOut->pMipInfo[i].pitch;
pOut->pMipInfo[i].pixelHeight = pOut->pMipInfo[i].height;
GetElemLib()->RestoreSurfaceInfo(elemMode,
expandX,
expandY,
&pixelBits,
&pOut->pMipInfo[i].pixelPitch,
&pOut->pMipInfo[i].pixelHeight);
}
}
}
if (localIn.flags.needEquation && (Log2(localIn.numFrags) == 0))
{
pOut->equationIndex = GetEquationIndex(&localIn, pOut);
}
if (localIn.flags.qbStereo)
{
if (pOut->pStereoInfo != NULL)
{
ComputeQbStereoInfo(pOut);
}
}
}
}
ADDR_ASSERT(pOut->surfSize != 0);
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceInfo
*
* @brief
* Interface function stub of AddrComputeSurfaceInfo.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoord(
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
if (GetFillSizeFieldsFlags() == TRUE)
{
if ((pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT)))
{
returnCode = ADDR_PARAMSIZEMISMATCH;
}
}
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT localIn = *pIn;
localIn.unalignedWidth = Max(pIn->unalignedWidth, 1u);
localIn.unalignedHeight = Max(pIn->unalignedHeight, 1u);
localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
localIn.numSlices = Max(pIn->numSlices, 1u);
localIn.numSamples = Max(pIn->numSamples, 1u);
localIn.numFrags = Max(pIn->numFrags, 1u);
if ((localIn.bpp < 8) ||
(localIn.bpp > 128) ||
((localIn.bpp % 8) != 0) ||
(localIn.sample >= localIn.numSamples) ||
(localIn.slice >= localIn.numSlices) ||
(localIn.mipId >= localIn.numMipLevels) ||
(IsTex3d(localIn.resourceType) &&
(Valid3DMipSliceIdConstraint(localIn.numSlices, localIn.mipId, localIn.slice) == FALSE)))
{
returnCode = ADDR_INVALIDPARAMS;
}
if (returnCode == ADDR_OK)
{
if (IsLinear(localIn.swizzleMode))
{
returnCode = ComputeSurfaceAddrFromCoordLinear(&localIn, pOut);
}
else
{
returnCode = ComputeSurfaceAddrFromCoordTiled(&localIn, pOut);
}
if (returnCode == ADDR_OK)
{
pOut->prtBlockIndex = static_cast<UINT_32>(pOut->addr / (64 * 1024));
}
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceCoordFromAddr
*
* @brief
* Interface function stub of ComputeSurfaceCoordFromAddr.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddr(
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
if (GetFillSizeFieldsFlags() == TRUE)
{
if ((pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT)))
{
returnCode = ADDR_PARAMSIZEMISMATCH;
}
}
if ((pIn->bpp < 8) ||
(pIn->bpp > 128) ||
((pIn->bpp % 8) != 0) ||
(pIn->bitPosition >= 8))
{
returnCode = ADDR_INVALIDPARAMS;
}
if (returnCode == ADDR_OK)
{
if (IsLinear(pIn->swizzleMode))
{
returnCode = ComputeSurfaceCoordFromAddrLinear(pIn, pOut);
}
else
{
returnCode = ComputeSurfaceCoordFromAddrTiled(pIn, pOut);
}
}
return returnCode;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// CMASK/HTILE
////////////////////////////////////////////////////////////////////////////////////////////////////
/**
************************************************************************************************************************
* Lib::ComputeHtileInfo
*
* @brief
* Interface function stub of AddrComputeHtilenfo
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeHtileInfo(
const ADDR2_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_HTILE_INFO_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_HTILE_INFO_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_HTILE_INFO_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeHtileInfo(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeHtileAddrFromCoord
*
* @brief
* Interface function stub of AddrComputeHtileAddrFromCoord
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeHtileAddrFromCoord(
const ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeHtileAddrFromCoord(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeHtileCoordFromAddr
*
* @brief
* Interface function stub of AddrComputeHtileCoordFromAddr
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeHtileCoordFromAddr(
const ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] output structure
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_HTILE_COORDFROMADDR_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_HTILE_COORDFROMADDR_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeHtileCoordFromAddr(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeCmaskInfo
*
* @brief
* Interface function stub of AddrComputeCmaskInfo
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeCmaskInfo(
const ADDR2_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_CMASK_INFO_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_CMASK_INFO_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_CMASK_INFO_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else if (pIn->cMaskFlags.linear)
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeCmaskInfo(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeCmaskAddrFromCoord
*
* @brief
* Interface function stub of AddrComputeCmaskAddrFromCoord
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeCmaskAddrFromCoord(
const ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeCmaskAddrFromCoord(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeCmaskCoordFromAddr
*
* @brief
* Interface function stub of AddrComputeCmaskCoordFromAddr
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeCmaskCoordFromAddr(
const ADDR2_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
ADDR_NOT_IMPLEMENTED();
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeFmaskInfo
*
* @brief
* Interface function stub of ComputeFmaskInfo.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeFmaskInfo(
const ADDR2_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_FMASK_INFO_OUTPUT* pOut ///< [out] output structure
)
{
ADDR_E_RETURNCODE returnCode;
BOOL_32 valid = (IsZOrderSwizzle(pIn->swizzleMode) == TRUE) &&
((pIn->numSamples > 0) || (pIn->numFrags > 0));
if (GetFillSizeFieldsFlags())
{
if ((pIn->size != sizeof(ADDR2_COMPUTE_FMASK_INFO_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_FMASK_INFO_OUTPUT)))
{
valid = FALSE;
}
}
if (valid == FALSE)
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
localIn.size = sizeof(ADDR2_COMPUTE_SURFACE_INFO_INPUT);
localOut.size = sizeof(ADDR2_COMPUTE_SURFACE_INFO_OUTPUT);
localIn.swizzleMode = pIn->swizzleMode;
localIn.numSlices = Max(pIn->numSlices, 1u);
localIn.width = Max(pIn->unalignedWidth, 1u);
localIn.height = Max(pIn->unalignedHeight, 1u);
localIn.bpp = GetFmaskBpp(pIn->numSamples, pIn->numFrags);
localIn.flags.fmask = 1;
localIn.numFrags = 1;
localIn.numSamples = 1;
localIn.resourceType = ADDR_RSRC_TEX_2D;
if (localIn.bpp == 8)
{
localIn.format = ADDR_FMT_8;
}
else if (localIn.bpp == 16)
{
localIn.format = ADDR_FMT_16;
}
else if (localIn.bpp == 32)
{
localIn.format = ADDR_FMT_32;
}
else
{
localIn.format = ADDR_FMT_32_32;
}
returnCode = ComputeSurfaceInfo(&localIn, &localOut);
if (returnCode == ADDR_OK)
{
pOut->pitch = localOut.pitch;
pOut->height = localOut.height;
pOut->baseAlign = localOut.baseAlign;
pOut->numSlices = localOut.numSlices;
pOut->fmaskBytes = static_cast<UINT_32>(localOut.surfSize);
pOut->sliceSize = static_cast<UINT_32>(localOut.sliceSize);
pOut->bpp = localIn.bpp;
pOut->numSamples = 1;
}
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeFmaskAddrFromCoord
*
* @brief
* Interface function stub of ComputeFmaskAddrFromCoord.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeFmaskAddrFromCoord(
const ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
ADDR_NOT_IMPLEMENTED();
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeFmaskCoordFromAddr
*
* @brief
* Interface function stub of ComputeFmaskAddrFromCoord.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeFmaskCoordFromAddr(
const ADDR2_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
ADDR_NOT_IMPLEMENTED();
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeDccInfo
*
* @brief
* Interface function to compute DCC key info
*
* @return
* return code of HwlComputeDccInfo
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeDccInfo(
const ADDR2_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_DCCINFO_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_DCCINFO_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_DCCINFO_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeDccInfo(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeDccAddrFromCoord
*
* @brief
* Interface function stub of ComputeDccAddrFromCoord
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeDccAddrFromCoord(
const ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] output structure
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_DCC_ADDRFROMCOORD_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_DCC_ADDRFROMCOORD_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeDccAddrFromCoord(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputePipeBankXor
*
* @brief
* Interface function stub of Addr2ComputePipeBankXor.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputePipeBankXor(
const ADDR2_COMPUTE_PIPEBANKXOR_INPUT* pIn,
ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT* pOut)
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_PIPEBANKXOR_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_PIPEBANKXOR_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else if (IsXor(pIn->swizzleMode) == FALSE)
{
returnCode = ADDR_NOTSUPPORTED;
}
else
{
returnCode = HwlComputePipeBankXor(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSlicePipeBankXor
*
* @brief
* Interface function stub of Addr2ComputeSlicePipeBankXor.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSlicePipeBankXor(
const ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT* pIn,
ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT* pOut)
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_SLICE_PIPEBANKXOR_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_SLICE_PIPEBANKXOR_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else if ((IsThin(pIn->resourceType, pIn->swizzleMode) == FALSE) ||
(IsNonPrtXor(pIn->swizzleMode) == FALSE) ||
(pIn->numSamples > 1))
{
returnCode = ADDR_NOTSUPPORTED;
}
else
{
returnCode = HwlComputeSlicePipeBankXor(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSubResourceOffsetForSwizzlePattern
*
* @brief
* Interface function stub of Addr2ComputeSubResourceOffsetForSwizzlePattern.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSubResourceOffsetForSwizzlePattern(
const ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT* pIn,
ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT* pOut)
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_INPUT)) ||
(pOut->size != sizeof(ADDR2_COMPUTE_SUBRESOURCE_OFFSET_FORSWIZZLEPATTERN_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeSubResourceOffsetForSwizzlePattern(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ExtractPipeBankXor
*
* @brief
* Internal function to extract bank and pipe xor bits from combined xor bits.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ExtractPipeBankXor(
UINT_32 pipeBankXor,
UINT_32 bankBits,
UINT_32 pipeBits,
UINT_32* pBankX,
UINT_32* pPipeX)
{
ADDR_E_RETURNCODE returnCode;
if (pipeBankXor < (1u << (pipeBits + bankBits)))
{
*pPipeX = pipeBankXor % (1 << pipeBits);
*pBankX = pipeBankXor >> pipeBits;
returnCode = ADDR_OK;
}
else
{
ADDR_ASSERT_ALWAYS();
returnCode = ADDR_INVALIDPARAMS;
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceInfoSanityCheck
*
* @brief
* Internal function to do basic sanity check before compute surface info
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoSanityCheck(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn ///< [in] input structure
) const
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
(pIn->size != sizeof(ADDR2_COMPUTE_SURFACE_INFO_INPUT)))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlComputeSurfaceInfoSanityCheck(pIn);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ApplyCustomizedPitchHeight
*
* @brief
* Helper function to override hw required row pitch/slice pitch by customrized one
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ApplyCustomizedPitchHeight(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
UINT_32 elementBytes, ///< [in] element bytes per element
UINT_32 pitchAlignInElement, ///< [in] pitch alignment in element
UINT_32* pPitch, ///< [in/out] pitch
UINT_32* pHeight ///< [in/out] height
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
if (pIn->numMipLevels <= 1)
{
if (pIn->pitchInElement > 0)
{
if ((pIn->pitchInElement % pitchAlignInElement) != 0)
{
returnCode = ADDR_INVALIDPARAMS;
}
else if (pIn->pitchInElement < (*pPitch))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
*pPitch = pIn->pitchInElement;
}
}
if (returnCode == ADDR_OK)
{
if (pIn->sliceAlign > 0)
{
UINT_32 customizedHeight = pIn->sliceAlign / elementBytes / (*pPitch);
if (customizedHeight * elementBytes * (*pPitch) != pIn->sliceAlign)
{
returnCode = ADDR_INVALIDPARAMS;
}
else if ((pIn->numSlices > 1) && ((*pHeight) != customizedHeight))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
*pHeight = customizedHeight;
}
}
}
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceInfoLinear
*
* @brief
* Internal function to calculate alignment for linear swizzle surface
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoLinear(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
{
return HwlComputeSurfaceInfoLinear(pIn, pOut);
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceInfoTiled
*
* @brief
* Internal function to calculate alignment for tiled swizzle surface
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceInfoTiled(
const ADDR2_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [out] output structure
) const
{
return HwlComputeSurfaceInfoTiled(pIn, pOut);
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceAddrFromCoordLinear
*
* @brief
* Internal function to calculate address from coord for linear swizzle surface
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoordLinear(
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
BOOL_32 valid = (pIn->numSamples <= 1) && (pIn->numFrags <= 1) && (pIn->pipeBankXor == 0);
if (valid)
{
if (IsTex1d(pIn->resourceType))
{
valid = (pIn->y == 0);
}
}
if (valid)
{
ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
ADDR2_MIP_INFO mipInfo[MaxMipLevels];
localIn.bpp = pIn->bpp;
localIn.flags = pIn->flags;
localIn.width = Max(pIn->unalignedWidth, 1u);
localIn.height = Max(pIn->unalignedHeight, 1u);
localIn.numSlices = Max(pIn->numSlices, 1u);
localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
localIn.resourceType = pIn->resourceType;
if (localIn.numMipLevels <= 1)
{
localIn.pitchInElement = pIn->pitchInElement;
}
localOut.pMipInfo = mipInfo;
returnCode = ComputeSurfaceInfoLinear(&localIn, &localOut);
if (returnCode == ADDR_OK)
{
pOut->addr = (localOut.sliceSize * pIn->slice) +
mipInfo[pIn->mipId].offset +
(pIn->y * mipInfo[pIn->mipId].pitch + pIn->x) * (pIn->bpp >> 3);
pOut->bitPosition = 0;
}
else
{
valid = FALSE;
}
}
if (valid == FALSE)
{
returnCode = ADDR_INVALIDPARAMS;
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceAddrFromCoordTiled
*
* @brief
* Internal function to calculate address from coord for tiled swizzle surface
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceAddrFromCoordTiled(
const ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut ///< [out] output structure
) const
{
return HwlComputeSurfaceAddrFromCoordTiled(pIn, pOut);
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceCoordFromAddrLinear
*
* @brief
* Internal function to calculate coord from address for linear swizzle surface
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddrLinear(
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
BOOL_32 valid = (pIn->numSamples <= 1) && (pIn->numFrags <= 1);
if (valid)
{
if (IsTex1d(pIn->resourceType))
{
valid = (pIn->unalignedHeight == 1);
}
}
if (valid)
{
ADDR2_COMPUTE_SURFACE_INFO_INPUT localIn = {0};
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT localOut = {0};
localIn.bpp = pIn->bpp;
localIn.flags = pIn->flags;
localIn.width = Max(pIn->unalignedWidth, 1u);
localIn.height = Max(pIn->unalignedHeight, 1u);
localIn.numSlices = Max(pIn->numSlices, 1u);
localIn.numMipLevels = Max(pIn->numMipLevels, 1u);
localIn.resourceType = pIn->resourceType;
if (localIn.numMipLevels <= 1)
{
localIn.pitchInElement = pIn->pitchInElement;
}
returnCode = ComputeSurfaceInfoLinear(&localIn, &localOut);
if (returnCode == ADDR_OK)
{
pOut->slice = static_cast<UINT_32>(pIn->addr / localOut.sliceSize);
pOut->sample = 0;
UINT_32 offsetInSlice = static_cast<UINT_32>(pIn->addr % localOut.sliceSize);
UINT_32 elementBytes = pIn->bpp >> 3;
UINT_32 mipOffsetInSlice = 0;
UINT_32 mipSize = 0;
UINT_32 mipId = 0;
for (; mipId < pIn->numMipLevels ; mipId++)
{
if (IsTex1d(pIn->resourceType))
{
mipSize = localOut.pitch * elementBytes;
}
else
{
UINT_32 currentMipHeight = (PowTwoAlign(localIn.height, (1 << mipId))) >> mipId;
mipSize = currentMipHeight * localOut.pitch * elementBytes;
}
if (mipSize == 0)
{
valid = FALSE;
break;
}
else if ((mipSize + mipOffsetInSlice) > offsetInSlice)
{
break;
}
else
{
mipOffsetInSlice += mipSize;
if ((mipId == (pIn->numMipLevels - 1)) ||
(mipOffsetInSlice >= localOut.sliceSize))
{
valid = FALSE;
}
}
}
if (valid)
{
pOut->mipId = mipId;
UINT_32 elemOffsetInMip = (offsetInSlice - mipOffsetInSlice) / elementBytes;
if (IsTex1d(pIn->resourceType))
{
if (elemOffsetInMip < localOut.pitch)
{
pOut->x = elemOffsetInMip;
pOut->y = 0;
}
else
{
valid = FALSE;
}
}
else
{
pOut->y = elemOffsetInMip / localOut.pitch;
pOut->x = elemOffsetInMip % localOut.pitch;
}
if ((pOut->slice >= pIn->numSlices) ||
(pOut->mipId >= pIn->numMipLevels) ||
(pOut->x >= Max((pIn->unalignedWidth >> pOut->mipId), 1u)) ||
(pOut->y >= Max((pIn->unalignedHeight >> pOut->mipId), 1u)) ||
(IsTex3d(pIn->resourceType) &&
(FALSE == Valid3DMipSliceIdConstraint(pIn->numSlices,
pOut->mipId,
pOut->slice))))
{
valid = FALSE;
}
}
}
else
{
valid = FALSE;
}
}
if (valid == FALSE)
{
returnCode = ADDR_INVALIDPARAMS;
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeSurfaceCoordFromAddrTiled
*
* @brief
* Internal function to calculate coord from address for tiled swizzle surface
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeSurfaceCoordFromAddrTiled(
const ADDR2_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] input structure
ADDR2_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut ///< [out] output structure
) const
{
ADDR_E_RETURNCODE returnCode = ADDR_NOTIMPLEMENTED;
ADDR_NOT_IMPLEMENTED();
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeBlockDimensionForSurf
*
* @brief
* Internal function to get block width/height/depth in element from surface input params.
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeBlockDimensionForSurf(
UINT_32* pWidth,
UINT_32* pHeight,
UINT_32* pDepth,
UINT_32 bpp,
UINT_32 numSamples,
AddrResourceType resourceType,
AddrSwizzleMode swizzleMode) const
{
ADDR_E_RETURNCODE returnCode = ComputeBlockDimension(pWidth,
pHeight,
pDepth,
bpp,
resourceType,
swizzleMode);
if ((returnCode == ADDR_OK) && (numSamples > 1) && IsThin(resourceType, swizzleMode))
{
const UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
const UINT_32 log2sample = Log2(numSamples);
const UINT_32 q = log2sample >> 1;
const UINT_32 r = log2sample & 1;
if (log2blkSize & 1)
{
*pWidth >>= q;
*pHeight >>= (q + r);
}
else
{
*pWidth >>= (q + r);
*pHeight >>= q;
}
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeBlockDimension
*
* @brief
* Internal function to get block width/height/depth in element without considering MSAA case
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeBlockDimension(
UINT_32* pWidth,
UINT_32* pHeight,
UINT_32* pDepth,
UINT_32 bpp,
AddrResourceType resourceType,
AddrSwizzleMode swizzleMode) const
{
ADDR_E_RETURNCODE returnCode = ADDR_OK;
UINT_32 eleBytes = bpp >> 3;
UINT_32 microBlockSizeTableIndex = Log2(eleBytes);
UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
if (IsThin(resourceType, swizzleMode))
{
UINT_32 log2blkSizeIn256B = log2blkSize - 8;
UINT_32 widthAmp = log2blkSizeIn256B / 2;
UINT_32 heightAmp = log2blkSizeIn256B - widthAmp;
ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block256_2d) / sizeof(Block256_2d[0]));
*pWidth = (Block256_2d[microBlockSizeTableIndex].w << widthAmp);
*pHeight = (Block256_2d[microBlockSizeTableIndex].h << heightAmp);
*pDepth = 1;
}
else if (IsThick(resourceType, swizzleMode))
{
UINT_32 log2blkSizeIn1KB = log2blkSize - 10;
UINT_32 averageAmp = log2blkSizeIn1KB / 3;
UINT_32 restAmp = log2blkSizeIn1KB % 3;
ADDR_ASSERT(microBlockSizeTableIndex < sizeof(Block1K_3d) / sizeof(Block1K_3d[0]));
*pWidth = Block1K_3d[microBlockSizeTableIndex].w << averageAmp;
*pHeight = Block1K_3d[microBlockSizeTableIndex].h << (averageAmp + (restAmp / 2));
*pDepth = Block1K_3d[microBlockSizeTableIndex].d << (averageAmp + ((restAmp != 0) ? 1 : 0));
}
else
{
ADDR_ASSERT_ALWAYS();
returnCode = ADDR_INVALIDPARAMS;
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::GetMipTailDim
*
* @brief
* Internal function to get out max dimension of first level in mip tail
*
* @return
* Max Width/Height/Depth value of the first mip fitted in mip tail
************************************************************************************************************************
*/
Dim3d Lib::GetMipTailDim(
AddrResourceType resourceType,
AddrSwizzleMode swizzleMode,
UINT_32 blockWidth,
UINT_32 blockHeight,
UINT_32 blockDepth) const
{
Dim3d out = {blockWidth, blockHeight, blockDepth};
UINT_32 log2blkSize = GetBlockSizeLog2(swizzleMode);
if (IsThick(resourceType, swizzleMode))
{
UINT_32 dim = log2blkSize % 3;
if (dim == 0)
{
out.h >>= 1;
}
else if (dim == 1)
{
out.w >>= 1;
}
else
{
out.d >>= 1;
}
}
else
{
if (log2blkSize & 1)
{
out.h >>= 1;
}
else
{
out.w >>= 1;
}
}
return out;
}
/**
************************************************************************************************************************
* Lib::ComputeSurface2DMicroBlockOffset
*
* @brief
* Internal function to calculate micro block (256B) offset from coord for 2D resource
*
* @return
* micro block (256B) offset for 2D resource
************************************************************************************************************************
*/
UINT_32 Lib::ComputeSurface2DMicroBlockOffset(
const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const
{
ADDR_ASSERT(IsThin(pIn->resourceType, pIn->swizzleMode));
UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
UINT_32 microBlockOffset = 0;
if (IsStandardSwizzle(pIn->resourceType, pIn->swizzleMode))
{
UINT_32 xBits = pIn->x << log2ElementBytes;
microBlockOffset = (xBits & 0xf) | ((pIn->y & 0x3) << 4);
if (log2ElementBytes < 3)
{
microBlockOffset |= (pIn->y & 0x4) << 4;
if (log2ElementBytes == 0)
{
microBlockOffset |= (pIn->y & 0x8) << 4;
}
else
{
microBlockOffset |= (xBits & 0x10) << 3;
}
}
else
{
microBlockOffset |= (xBits & 0x30) << 2;
}
}
else if (IsDisplaySwizzle(pIn->resourceType, pIn->swizzleMode))
{
if (log2ElementBytes == 4)
{
microBlockOffset = (GetBit(pIn->x, 0) << 4) |
(GetBit(pIn->y, 0) << 5) |
(GetBit(pIn->x, 1) << 6) |
(GetBit(pIn->y, 1) << 7);
}
else
{
microBlockOffset = GetBits(pIn->x, 0, 3, log2ElementBytes) |
GetBits(pIn->y, 1, 2, 3 + log2ElementBytes) |
GetBits(pIn->x, 3, 1, 5 + log2ElementBytes) |
GetBits(pIn->y, 3, 1, 6 + log2ElementBytes);
microBlockOffset = GetBits(microBlockOffset, 0, 4, 0) |
(GetBit(pIn->y, 0) << 4) |
GetBits(microBlockOffset, 4, 3, 5);
}
}
else if (IsRotateSwizzle(pIn->swizzleMode))
{
microBlockOffset = GetBits(pIn->y, 0, 3, log2ElementBytes) |
GetBits(pIn->x, 1, 2, 3 + log2ElementBytes) |
GetBits(pIn->x, 3, 1, 5 + log2ElementBytes) |
GetBits(pIn->y, 3, 1, 6 + log2ElementBytes);
microBlockOffset = GetBits(microBlockOffset, 0, 4, 0) |
(GetBit(pIn->x, 0) << 4) |
GetBits(microBlockOffset, 4, 3, 5);
if (log2ElementBytes == 3)
{
microBlockOffset = GetBits(microBlockOffset, 0, 6, 0) |
GetBits(pIn->x, 1, 2, 6);
}
}
return microBlockOffset;
}
/**
************************************************************************************************************************
* Lib::ComputeSurface3DMicroBlockOffset
*
* @brief
* Internal function to calculate micro block (1KB) offset from coord for 3D resource
*
* @return
* micro block (1KB) offset for 3D resource
************************************************************************************************************************
*/
UINT_32 Lib::ComputeSurface3DMicroBlockOffset(
const _ADDR2_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn) const
{
ADDR_ASSERT(IsThick(pIn->resourceType, pIn->swizzleMode));
UINT_32 log2ElementBytes = Log2(pIn->bpp >> 3);
UINT_32 microBlockOffset = 0;
if (IsStandardSwizzle(pIn->resourceType, pIn->swizzleMode))
{
if (log2ElementBytes == 0)
{
microBlockOffset = ((pIn->slice & 4) >> 2) | ((pIn->y & 4) >> 1);
}
else if (log2ElementBytes == 1)
{
microBlockOffset = ((pIn->slice & 4) >> 2) | ((pIn->y & 4) >> 1);
}
else if (log2ElementBytes == 2)
{
microBlockOffset = ((pIn->y & 4) >> 2) | ((pIn->x & 4) >> 1);
}
else if (log2ElementBytes == 3)
{
microBlockOffset = (pIn->x & 6) >> 1;
}
else
{
microBlockOffset = pIn->x & 3;
}
microBlockOffset <<= 8;
UINT_32 xBits = pIn->x << log2ElementBytes;
microBlockOffset |= (xBits & 0xf) | ((pIn->y & 0x3) << 4) | ((pIn->slice & 0x3) << 6);
}
else if (IsZOrderSwizzle(pIn->swizzleMode))
{
UINT_32 xh, yh, zh;
if (log2ElementBytes == 0)
{
microBlockOffset =
(pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->x & 2) << 1) | ((pIn->y & 2) << 2);
microBlockOffset = microBlockOffset | ((pIn->slice & 3) << 4) | ((pIn->x & 4) << 4);
xh = pIn->x >> 3;
yh = pIn->y >> 2;
zh = pIn->slice >> 2;
}
else if (log2ElementBytes == 1)
{
microBlockOffset =
(pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->x & 2) << 1) | ((pIn->y & 2) << 2);
microBlockOffset = (microBlockOffset << 1) | ((pIn->slice & 3) << 5);
xh = pIn->x >> 2;
yh = pIn->y >> 2;
zh = pIn->slice >> 2;
}
else if (log2ElementBytes == 2)
{
microBlockOffset =
(pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->x & 2) << 1) | ((pIn->slice & 1) << 3);
microBlockOffset = (microBlockOffset << 2) | ((pIn->y & 2) << 5);
xh = pIn->x >> 2;
yh = pIn->y >> 2;
zh = pIn->slice >> 1;
}
else if (log2ElementBytes == 3)
{
microBlockOffset =
(pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->slice & 1) << 2) | ((pIn->x & 2) << 2);
microBlockOffset <<= 3;
xh = pIn->x >> 2;
yh = pIn->y >> 1;
zh = pIn->slice >> 1;
}
else
{
microBlockOffset =
(((pIn->x & 1) | ((pIn->y & 1) << 1) | ((pIn->slice & 1) << 2)) << 4);
xh = pIn->x >> 1;
yh = pIn->y >> 1;
zh = pIn->slice >> 1;
}
microBlockOffset |= ((MortonGen3d(xh, yh, zh, 1) << 7) & 0x380);
}
return microBlockOffset;
}
/**
************************************************************************************************************************
* Lib::GetPipeXorBits
*
* @brief
* Internal function to get bits number for pipe/se xor operation
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
UINT_32 Lib::GetPipeXorBits(
UINT_32 macroBlockBits) const
{
ADDR_ASSERT(macroBlockBits >= m_pipeInterleaveLog2);
// Total available xor bits
UINT_32 xorBits = macroBlockBits - m_pipeInterleaveLog2;
// Pipe/Se xor bits
UINT_32 pipeBits = Min(xorBits, m_pipesLog2 + m_seLog2);
return pipeBits;
}
/**
************************************************************************************************************************
* Lib::GetBankXorBits
*
* @brief
* Internal function to get bits number for pipe/se xor operation
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
UINT_32 Lib::GetBankXorBits(
UINT_32 macroBlockBits) const
{
UINT_32 pipeBits = GetPipeXorBits(macroBlockBits);
// Bank xor bits
UINT_32 bankBits = Min(macroBlockBits - pipeBits - m_pipeInterleaveLog2, m_banksLog2);
return bankBits;
}
/**
************************************************************************************************************************
* Lib::Addr2GetPreferredSurfaceSetting
*
* @brief
* Internal function to get suggested surface information for cliet to use
*
* @return
* ADDR_E_RETURNCODE
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::Addr2GetPreferredSurfaceSetting(
const ADDR2_GET_PREFERRED_SURF_SETTING_INPUT* pIn,
ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT* pOut) const
{
ADDR_E_RETURNCODE returnCode;
if ((GetFillSizeFieldsFlags() == TRUE) &&
((pIn->size != sizeof(ADDR2_GET_PREFERRED_SURF_SETTING_INPUT)) ||
(pOut->size != sizeof(ADDR2_GET_PREFERRED_SURF_SETTING_OUTPUT))))
{
returnCode = ADDR_INVALIDPARAMS;
}
else
{
returnCode = HwlGetPreferredSurfaceSetting(pIn, pOut);
}
return returnCode;
}
/**
************************************************************************************************************************
* Lib::ComputeBlock256Equation
*
* @brief
* Compute equation for block 256B
*
* @return
* If equation computed successfully
*
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeBlock256Equation(
AddrResourceType rsrcType,
AddrSwizzleMode swMode,
UINT_32 elementBytesLog2,
ADDR_EQUATION* pEquation) const
{
ADDR_E_RETURNCODE ret;
if (IsBlock256b(swMode))
{
ret = HwlComputeBlock256Equation(rsrcType, swMode, elementBytesLog2, pEquation);
}
else
{
ADDR_ASSERT_ALWAYS();
ret = ADDR_INVALIDPARAMS;
}
return ret;
}
/**
************************************************************************************************************************
* Lib::ComputeThinEquation
*
* @brief
* Compute equation for 2D/3D resource which use THIN mode
*
* @return
* If equation computed successfully
*
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeThinEquation(
AddrResourceType rsrcType,
AddrSwizzleMode swMode,
UINT_32 elementBytesLog2,
ADDR_EQUATION* pEquation) const
{
ADDR_E_RETURNCODE ret;
if (IsThin(rsrcType, swMode))
{
ret = HwlComputeThinEquation(rsrcType, swMode, elementBytesLog2, pEquation);
}
else
{
ADDR_ASSERT_ALWAYS();
ret = ADDR_INVALIDPARAMS;
}
return ret;
}
/**
************************************************************************************************************************
* Lib::ComputeThickEquation
*
* @brief
* Compute equation for 3D resource which use THICK mode
*
* @return
* If equation computed successfully
*
************************************************************************************************************************
*/
ADDR_E_RETURNCODE Lib::ComputeThickEquation(
AddrResourceType rsrcType,
AddrSwizzleMode swMode,
UINT_32 elementBytesLog2,
ADDR_EQUATION* pEquation) const
{
ADDR_E_RETURNCODE ret;
if (IsThick(rsrcType, swMode))
{
ret = HwlComputeThickEquation(rsrcType, swMode, elementBytesLog2, pEquation);
}
else
{
ADDR_ASSERT_ALWAYS();
ret = ADDR_INVALIDPARAMS;
}
return ret;
}
/**
************************************************************************************************************************
* Lib::ComputeQbStereoInfo
*
* @brief
* Get quad buffer stereo information
* @return
* N/A
************************************************************************************************************************
*/
VOID Lib::ComputeQbStereoInfo(
ADDR2_COMPUTE_SURFACE_INFO_OUTPUT* pOut ///< [in,out] updated pOut+pStereoInfo
) const
{
ADDR_ASSERT(pOut->bpp >= 8);
ADDR_ASSERT((pOut->surfSize % pOut->baseAlign) == 0);
// Save original height
pOut->pStereoInfo->eyeHeight = pOut->height;
// Right offset
pOut->pStereoInfo->rightOffset = static_cast<UINT_32>(pOut->surfSize);
// Double height
pOut->height <<= 1;
ADDR_ASSERT(pOut->height <= MaxSurfaceHeight);
pOut->pixelHeight <<= 1;
// Double size
pOut->surfSize <<= 1;
}
} // V2
} // Addr