Home | History | Annotate | Download | only in core
      1 /*
      2  * Copyright  2014 Advanced Micro Devices, Inc.
      3  * All Rights Reserved.
      4  *
      5  * Permission is hereby granted, free of charge, to any person obtaining
      6  * a copy of this software and associated documentation files (the
      7  * "Software"), to deal in the Software without restriction, including
      8  * without limitation the rights to use, copy, modify, merge, publish,
      9  * distribute, sub license, and/or sell copies of the Software, and to
     10  * permit persons to whom the Software is furnished to do so, subject to
     11  * the following conditions:
     12  *
     13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     14  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
     15  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
     16  * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
     17  * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
     19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
     20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
     21  *
     22  * The above copyright notice and this permission notice (including the
     23  * next paragraph) shall be included in all copies or substantial portions
     24  * of the Software.
     25  */
     26 
     27 /**
     28 ****************************************************************************************************
     29 * @file  addrelemlib.h
     30 * @brief Contains the class for element/pixel related functions.
     31 ****************************************************************************************************
     32 */
     33 
     34 #ifndef __ELEM_LIB_H__
     35 #define __ELEM_LIB_H__
     36 
     37 #include "addrinterface.h"
     38 #include "addrobject.h"
     39 #include "addrcommon.h"
     40 
     41 namespace Addr
     42 {
     43 
     44 class Lib;
     45 
     46 // The masks for property bits within the Properties INT_32
     47 union ComponentFlags
     48 {
     49     struct
     50     {
     51         UINT_32 byteAligned    : 1;    ///< all components are byte aligned
     52         UINT_32 exportNorm     : 1;    ///< components support R6xx NORM compression
     53         UINT_32 floatComp      : 1;    ///< there is at least one floating point component
     54     };
     55 
     56     UINT_32 value;
     57 };
     58 
     59 // Copy from legacy lib's NumberType
     60 enum NumberType
     61 {
     62     // The following number types have the range [-1..1]
     63     ADDR_NO_NUMBER,         // This component doesn't exist and has no default value
     64     ADDR_EPSILON,           // Force component value to integer 0x00000001
     65     ADDR_ZERO,              // Force component value to integer 0x00000000
     66     ADDR_ONE,               // Force component value to floating point 1.0
     67     // Above values don't have any bits per component (keep ADDR_ONE the last of these)
     68 
     69     ADDR_UNORM,             // Unsigned normalized (repeating fraction) full precision
     70     ADDR_SNORM,             // Signed normalized (repeating fraction) full precision
     71     ADDR_GAMMA,             // Gamma-corrected, full precision
     72 
     73     ADDR_UNORM_R5XXRB,      // Unsigned normalized (repeating fraction) for r5xx RB
     74     ADDR_SNORM_R5XXRB,      // Signed normalized (repeating fraction) for r5xx RB
     75     ADDR_GAMMA_R5XXRB,      // Gamma-corrected for r5xx RB (note: unnormalized value)
     76     ADDR_UNORM_R5XXBC,      // Unsigned normalized (repeating fraction) for r5xx BC
     77     ADDR_SNORM_R5XXBC,      // Signed normalized (repeating fraction) for r5xx BC
     78     ADDR_GAMMA_R5XXBC,      // Gamma-corrected for r5xx BC (note: unnormalized value)
     79 
     80     ADDR_UNORM_R6XX,        // Unsigned normalized (repeating fraction) for R6xx
     81     ADDR_UNORM_R6XXDB,      // Unorms for 24-bit depth: one value differs from ADDR_UNORM_R6XX
     82     ADDR_SNORM_R6XX,        // Signed normalized (repeating fraction) for R6xx
     83     ADDR_GAMMA8_R6XX,       // Gamma-corrected for r6xx
     84     ADDR_GAMMA8_R7XX_TP,    // Gamma-corrected for r7xx TP 12bit unorm 8.4.
     85 
     86     ADDR_U4FLOATC,          // Unsigned float: 4-bit exponent, bias=15, no NaN, clamp [0..1]
     87     ADDR_GAMMA_4SEG,        // Gamma-corrected, four segment approximation
     88     ADDR_U0FIXED,           // Unsigned 0.N-bit fixed point
     89 
     90     // The following number types have large ranges (LEAVE ADDR_USCALED first or fix Finish routine)
     91     ADDR_USCALED,           // Unsigned integer converted to/from floating point
     92     ADDR_SSCALED,           // Signed integer converted to/from floating point
     93     ADDR_USCALED_R5XXRB,    // Unsigned integer to/from floating point for r5xx RB
     94     ADDR_SSCALED_R5XXRB,    // Signed integer to/from floating point for r5xx RB
     95     ADDR_UINT_BITS,         // Keep in unsigned integer form, clamped to specified range
     96     ADDR_SINT_BITS,         // Keep in signed integer form, clamped to specified range
     97     ADDR_UINTBITS,          // @@ remove Keep in unsigned integer form, use modulus to reduce bits
     98     ADDR_SINTBITS,          // @@ remove Keep in signed integer form, use modulus to reduce bits
     99 
    100     // The following number types and ADDR_U4FLOATC have exponents
    101     // (LEAVE ADDR_S8FLOAT first or fix Finish routine)
    102     ADDR_S8FLOAT,           // Signed floating point with 8-bit exponent, bias=127
    103     ADDR_S8FLOAT32,         // 32-bit IEEE float, passes through NaN values
    104     ADDR_S5FLOAT,           // Signed floating point with 5-bit exponent, bias=15
    105     ADDR_S5FLOATM,          // Signed floating point with 5-bit exponent, bias=15, no NaN/Inf
    106     ADDR_U5FLOAT,           // Signed floating point with 5-bit exponent, bias=15
    107     ADDR_U3FLOATM,          // Unsigned floating point with 3-bit exponent, bias=3
    108 
    109     ADDR_S5FIXED,           // Signed 5.N-bit fixed point, with rounding
    110 
    111     ADDR_END_NUMBER         // Used for range comparisons
    112 };
    113 
    114 // Copy from legacy lib's AddrElement
    115 enum ElemMode
    116 {
    117     // These formats allow both packing an unpacking
    118     ADDR_ROUND_BY_HALF,      // add 1/2 and truncate when packing this element
    119     ADDR_ROUND_TRUNCATE,     // truncate toward 0 for sign/mag, else toward neg
    120     ADDR_ROUND_DITHER,       // Pack by dithering -- requires (x,y) position
    121 
    122     // These formats only allow unpacking, no packing
    123     ADDR_UNCOMPRESSED,       // Elements are not compressed: one data element per pixel/texel
    124     ADDR_EXPANDED,           // Elements are split up and stored in multiple data elements
    125     ADDR_PACKED_STD,         // Elements are compressed into ExpandX by ExpandY data elements
    126     ADDR_PACKED_REV,         // Like ADDR_PACKED, but X order of pixels is reverved
    127     ADDR_PACKED_GBGR,        // Elements are compressed 4:2:2 in G1B_G0R order (high to low)
    128     ADDR_PACKED_BGRG,        // Elements are compressed 4:2:2 in BG1_RG0 order (high to low)
    129     ADDR_PACKED_BC1,         // Each data element is uncompressed to a 4x4 pixel/texel array
    130     ADDR_PACKED_BC2,         // Each data element is uncompressed to a 4x4 pixel/texel array
    131     ADDR_PACKED_BC3,         // Each data element is uncompressed to a 4x4 pixel/texel array
    132     ADDR_PACKED_BC4,         // Each data element is uncompressed to a 4x4 pixel/texel array
    133     ADDR_PACKED_BC5,         // Each data element is uncompressed to a 4x4 pixel/texel array
    134     ADDR_PACKED_ETC2_64BPP,  // ETC2 formats that use 64bpp to represent each 4x4 block
    135     ADDR_PACKED_ETC2_128BPP, // ETC2 formats that use 128bpp to represent each 4x4 block
    136     ADDR_PACKED_ASTC,        // Various ASTC formats, all are 128bpp with varying block sizes
    137 
    138     // These formats provide various kinds of compression
    139     ADDR_ZPLANE_R5XX,        // Compressed Zplane using r5xx architecture format
    140     ADDR_ZPLANE_R6XX,        // Compressed Zplane using r6xx architecture format
    141     //@@ Fill in the compression modes
    142 
    143     ADDR_END_ELEMENT         // Used for range comparisons
    144 };
    145 
    146 enum DepthPlanarType
    147 {
    148     ADDR_DEPTH_PLANAR_NONE = 0, // No plane z/stencl
    149     ADDR_DEPTH_PLANAR_R600 = 1, // R600 z and stencil planes are store within a tile
    150     ADDR_DEPTH_PLANAR_R800 = 2, // R800 has separate z and stencil planes
    151 };
    152 
    153 /**
    154 ****************************************************************************************************
    155 *   PixelFormatInfo
    156 *
    157 *   @brief
    158 *       Per component info
    159 *
    160 ****************************************************************************************************
    161 */
    162 struct PixelFormatInfo
    163 {
    164     UINT_32             compBit[4];
    165     NumberType          numType[4];
    166     UINT_32             compStart[4];
    167     ElemMode            elemMode;
    168     UINT_32             comps;          ///< Number of components
    169 };
    170 
    171 /**
    172 ****************************************************************************************************
    173 * @brief This class contains asic indepentent element related attributes and operations
    174 ****************************************************************************************************
    175 */
    176 class ElemLib : public Object
    177 {
    178 protected:
    179     ElemLib(Lib* pAddrLib);
    180 
    181 public:
    182 
    183     /// Makes this class virtual
    184     virtual ~ElemLib();
    185 
    186     static ElemLib* Create(
    187         const Lib* pAddrLib);
    188 
    189     /// The implementation is only for R6xx/R7xx, so make it virtual in case we need for R8xx
    190     BOOL_32 PixGetExportNorm(
    191         AddrColorFormat colorFmt,
    192         AddrSurfaceNumber numberFmt, AddrSurfaceSwap swap) const;
    193 
    194     /// Below method are asic independent, so make them just static.
    195     /// Remove static if we need different operation in hwl.
    196 
    197     VOID    Flt32ToDepthPixel(
    198         AddrDepthFormat format, const ADDR_FLT_32 comps[2], UINT_8 *pPixel) const;
    199 
    200     VOID    Flt32ToColorPixel(
    201         AddrColorFormat format, AddrSurfaceNumber surfNum, AddrSurfaceSwap surfSwap,
    202         const ADDR_FLT_32 comps[4], UINT_8 *pPixel) const;
    203 
    204     static VOID    Flt32sToInt32s(
    205         ADDR_FLT_32 value, UINT_32 bits, NumberType numberType, UINT_32* pResult);
    206 
    207     static VOID    Int32sToPixel(
    208         UINT_32 numComps, UINT_32* pComps, UINT_32* pCompBits, UINT_32* pCompStart,
    209         ComponentFlags properties, UINT_32 resultBits, UINT_8* pPixel);
    210 
    211     VOID    PixGetColorCompInfo(
    212         AddrColorFormat format, AddrSurfaceNumber number, AddrSurfaceSwap swap,
    213         PixelFormatInfo* pInfo) const;
    214 
    215     VOID    PixGetDepthCompInfo(
    216         AddrDepthFormat format, PixelFormatInfo* pInfo) const;
    217 
    218     UINT_32 GetBitsPerPixel(
    219         AddrFormat format, ElemMode* pElemMode = NULL,
    220         UINT_32* pExpandX = NULL, UINT_32* pExpandY = NULL, UINT_32* pBitsUnused = NULL);
    221 
    222     static VOID    SetClearComps(
    223         ADDR_FLT_32 comps[4], BOOL_32 clearColor, BOOL_32 float32);
    224 
    225     VOID    AdjustSurfaceInfo(
    226         ElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
    227         UINT_32* pBpp, UINT_32* pBasePitch, UINT_32* pWidth, UINT_32* pHeight);
    228 
    229     VOID    RestoreSurfaceInfo(
    230         ElemMode elemMode, UINT_32 expandX, UINT_32 expandY,
    231         UINT_32* pBpp, UINT_32* pWidth, UINT_32* pHeight);
    232 
    233     /// Checks if depth and stencil are planar inside a tile
    234     BOOL_32 IsDepthStencilTilePlanar()
    235     {
    236         return (m_depthPlanarType == ADDR_DEPTH_PLANAR_R600) ? TRUE : FALSE;
    237     }
    238 
    239     /// Sets m_configFlags, copied from AddrLib
    240     VOID    SetConfigFlags(ConfigFlags flags)
    241     {
    242         m_configFlags = flags;
    243     }
    244 
    245     static BOOL_32 IsCompressed(AddrFormat format);
    246     static BOOL_32 IsBlockCompressed(AddrFormat format);
    247     static BOOL_32 IsExpand3x(AddrFormat format);
    248     static BOOL_32 IsMacroPixelPacked(AddrFormat format);
    249 
    250 protected:
    251 
    252     static VOID    GetCompBits(
    253         UINT_32 c0, UINT_32 c1, UINT_32 c2, UINT_32 c3,
    254         PixelFormatInfo* pInfo,
    255         ElemMode elemMode = ADDR_ROUND_BY_HALF);
    256 
    257     static VOID    GetCompType(
    258         AddrColorFormat format, AddrSurfaceNumber numType,
    259         PixelFormatInfo* pInfo);
    260 
    261     static VOID    GetCompSwap(
    262         AddrSurfaceSwap swap, PixelFormatInfo* pInfo);
    263 
    264     static VOID    SwapComps(
    265         UINT_32 c0, UINT_32 c1, PixelFormatInfo* pInfo);
    266 
    267 private:
    268 
    269     UINT_32             m_fp16ExportNorm;   ///< If allow FP16 to be reported as EXPORT_NORM
    270     DepthPlanarType     m_depthPlanarType;
    271 
    272     ConfigFlags         m_configFlags;      ///< Copy of AddrLib's configFlags
    273     Addr::Lib* const    m_pAddrLib;         ///< Pointer to parent addrlib instance
    274 };
    275 
    276 } //Addr
    277 
    278 #endif
    279 
    280