Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove duplicate enums in RENDER_SURFACE_STATE 

Remove:
- tagSHADER_CHANNEL_SELECT_ALPHA
- tagSHADER_CHANNEL_SELECT_BLUE
- tagSHADER_CHANNEL_SELECT_GREEN
- tagSHADER_CHANNEL_SELECT_RED
Replace:
- tagSHADER_CHANNEL_SELECT

Change-Id: Ia08ac5920107e0c2f4c3e3ef64622f1cd5254174
Signed-off-by: Krzysztof Gibala <krzysztof.gibala@intel.com>
This commit is contained in:
Krzysztof Gibala 2019-09-11 09:50:18 +02:00 committed by sys_ocldev
parent ae7ec589fc
commit 04e1d73fcc
7 changed files with 169 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
core/gen11/hw_cmds_generated.inl
View File

@ -2450,38 +2450,14 @@ typedef struct tagRENDER_SURFACE_STATE {
HALF_PITCH_FOR_CHROMA_DISABLE = 0x0,
HALF_PITCH_FOR_CHROMA_ENABLE = 0x1,
} HALF_PITCH_FOR_CHROMA;
typedef enum tagSHADER_CHANNEL_SELECT_ALPHA {
SHADER_CHANNEL_SELECT_ALPHA_ZERO = 0x0,
SHADER_CHANNEL_SELECT_ALPHA_ONE = 0x1,
SHADER_CHANNEL_SELECT_ALPHA_RED = 0x4,
SHADER_CHANNEL_SELECT_ALPHA_GREEN = 0x5,
SHADER_CHANNEL_SELECT_ALPHA_BLUE = 0x6,
SHADER_CHANNEL_SELECT_ALPHA_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_ALPHA;
typedef enum tagSHADER_CHANNEL_SELECT_BLUE {
SHADER_CHANNEL_SELECT_BLUE_ZERO = 0x0,
SHADER_CHANNEL_SELECT_BLUE_ONE = 0x1,
SHADER_CHANNEL_SELECT_BLUE_RED = 0x4,
SHADER_CHANNEL_SELECT_BLUE_GREEN = 0x5,
SHADER_CHANNEL_SELECT_BLUE_BLUE = 0x6,
SHADER_CHANNEL_SELECT_BLUE_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_BLUE;
typedef enum tagSHADER_CHANNEL_SELECT_GREEN {
SHADER_CHANNEL_SELECT_GREEN_ZERO = 0x0,
SHADER_CHANNEL_SELECT_GREEN_ONE = 0x1,
SHADER_CHANNEL_SELECT_GREEN_RED = 0x4,
SHADER_CHANNEL_SELECT_GREEN_GREEN = 0x5,
SHADER_CHANNEL_SELECT_GREEN_BLUE = 0x6,
SHADER_CHANNEL_SELECT_GREEN_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_GREEN;
typedef enum tagSHADER_CHANNEL_SELECT_RED {
SHADER_CHANNEL_SELECT_RED_ZERO = 0x0,
SHADER_CHANNEL_SELECT_RED_ONE = 0x1,
SHADER_CHANNEL_SELECT_RED_RED = 0x4,
SHADER_CHANNEL_SELECT_RED_GREEN = 0x5,
SHADER_CHANNEL_SELECT_RED_BLUE = 0x6,
SHADER_CHANNEL_SELECT_RED_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_RED;
typedef enum tagSHADER_CHANNEL_SELECT {
SHADER_CHANNEL_SELECT_ZERO = 0x0,
SHADER_CHANNEL_SELECT_ONE = 0x1,
SHADER_CHANNEL_SELECT_RED = 0x4,
SHADER_CHANNEL_SELECT_GREEN = 0x5,
SHADER_CHANNEL_SELECT_BLUE = 0x6,
SHADER_CHANNEL_SELECT_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT;
typedef enum tagMEMORY_COMPRESSION_MODE {
MEMORY_COMPRESSION_MODE_HORIZONTAL = 0x0,
MEMORY_COMPRESSION_MODE_VERTICAL = 0x1,
@ -2518,10 +2494,10 @@ typedef struct tagRENDER_SURFACE_STATE {
TheStructure.Common.TileAddressMappingMode = TILE_ADDRESS_MAPPING_MODE_GEN9;
TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT;
TheStructure.Common.TiledResourceMode = TILED_RESOURCE_MODE_NONE;
TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ALPHA_ZERO;
TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_BLUE_ZERO;
TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_GREEN_ZERO;
TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_RED_ZERO;
TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL;
TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples = NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1;
TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat = MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS;
@ -2770,29 +2746,29 @@ typedef struct tagRENDER_SURFACE_STATE {
inline uint32_t getResourceMinLod(void) const {
return (TheStructure.Common.ResourceMinLod);
}
inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT_ALPHA value) {
inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectAlpha = value;
}
inline SHADER_CHANNEL_SELECT_ALPHA getShaderChannelSelectAlpha(void) const {
return static_cast<SHADER_CHANNEL_SELECT_ALPHA>(TheStructure.Common.ShaderChannelSelectAlpha);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha);
}
inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT_BLUE value) {
inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectBlue = value;
}
inline SHADER_CHANNEL_SELECT_BLUE getShaderChannelSelectBlue(void) const {
return static_cast<SHADER_CHANNEL_SELECT_BLUE>(TheStructure.Common.ShaderChannelSelectBlue);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue);
}
inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT_GREEN value) {
inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectGreen = value;
}
inline SHADER_CHANNEL_SELECT_GREEN getShaderChannelSelectGreen(void) const {
return static_cast<SHADER_CHANNEL_SELECT_GREEN>(TheStructure.Common.ShaderChannelSelectGreen);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen);
}
inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT_RED value) {
inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectRed = value;
}
inline SHADER_CHANNEL_SELECT_RED getShaderChannelSelectRed(void) const {
return static_cast<SHADER_CHANNEL_SELECT_RED>(TheStructure.Common.ShaderChannelSelectRed);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed);
}
inline void setMemoryCompressionEnable(const bool value) {
TheStructure.Common.MemoryCompressionEnable = value;

72
core/gen8/hw_cmds_generated.inl
View File

@ -2427,38 +2427,14 @@ typedef struct tagRENDER_SURFACE_STATE {
AUXILIARY_SURFACE_MODE_AUX_HIZ = 0x3,
AUXILIARY_SURFACE_MODE_AUX_CCS_E = 0x5,
} AUXILIARY_SURFACE_MODE;
typedef enum tagSHADER_CHANNEL_SELECT_ALPHA {
SHADER_CHANNEL_SELECT_ALPHA_ZERO = 0x0,
SHADER_CHANNEL_SELECT_ALPHA_ONE = 0x1,
SHADER_CHANNEL_SELECT_ALPHA_RED = 0x4,
SHADER_CHANNEL_SELECT_ALPHA_GREEN = 0x5,
SHADER_CHANNEL_SELECT_ALPHA_BLUE = 0x6,
SHADER_CHANNEL_SELECT_ALPHA_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_ALPHA;
typedef enum tagSHADER_CHANNEL_SELECT_BLUE {
SHADER_CHANNEL_SELECT_BLUE_ZERO = 0x0,
SHADER_CHANNEL_SELECT_BLUE_ONE = 0x1,
SHADER_CHANNEL_SELECT_BLUE_RED = 0x4,
SHADER_CHANNEL_SELECT_BLUE_GREEN = 0x5,
SHADER_CHANNEL_SELECT_BLUE_BLUE = 0x6,
SHADER_CHANNEL_SELECT_BLUE_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_BLUE;
typedef enum tagSHADER_CHANNEL_SELECT_GREEN {
SHADER_CHANNEL_SELECT_GREEN_ZERO = 0x0,
SHADER_CHANNEL_SELECT_GREEN_ONE = 0x1,
SHADER_CHANNEL_SELECT_GREEN_RED = 0x4,
SHADER_CHANNEL_SELECT_GREEN_GREEN = 0x5,
SHADER_CHANNEL_SELECT_GREEN_BLUE = 0x6,
SHADER_CHANNEL_SELECT_GREEN_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_GREEN;
typedef enum tagSHADER_CHANNEL_SELECT_RED {
SHADER_CHANNEL_SELECT_RED_ZERO = 0x0,
SHADER_CHANNEL_SELECT_RED_ONE = 0x1,
SHADER_CHANNEL_SELECT_RED_RED = 0x4,
SHADER_CHANNEL_SELECT_RED_GREEN = 0x5,
SHADER_CHANNEL_SELECT_RED_BLUE = 0x6,
SHADER_CHANNEL_SELECT_RED_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_RED;
typedef enum tagSHADER_CHANNEL_SELECT {
SHADER_CHANNEL_SELECT_ZERO = 0x0,
SHADER_CHANNEL_SELECT_ONE = 0x1,
SHADER_CHANNEL_SELECT_RED = 0x4,
SHADER_CHANNEL_SELECT_GREEN = 0x5,
SHADER_CHANNEL_SELECT_BLUE = 0x6,
SHADER_CHANNEL_SELECT_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT;
typedef enum tagALPHA_CLEAR_COLOR {
ALPHA_CLEAR_COLOR_CC_ZERO = 0x0,
ALPHA_CLEAR_COLOR_CC_ONE = 0x1,
@ -2490,10 +2466,10 @@ typedef struct tagRENDER_SURFACE_STATE {
TheStructure.Common.SurfaceVerticalAlignment = SURFACE_VERTICAL_ALIGNMENT_VALIGN_4;
TheStructure.Common.SurfaceType = SURFACE_TYPE_SURFTYPE_1D;
TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT;
TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ALPHA_ZERO;
TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_BLUE_ZERO;
TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_GREEN_ZERO;
TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_RED_ZERO;
TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.AlphaClearColor = ALPHA_CLEAR_COLOR_CC_ZERO;
TheStructure.Common.BlueClearColor = BLUE_CLEAR_COLOR_CC_ZERO;
TheStructure.Common.GreenClearColor = GREEN_CLEAR_COLOR_CC_ZERO;
@ -2705,29 +2681,29 @@ typedef struct tagRENDER_SURFACE_STATE {
inline uint32_t getResourceMinLod(void) const {
return (TheStructure.Common.ResourceMinLod);
}
inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT_ALPHA value) {
inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectAlpha = value;
}
inline SHADER_CHANNEL_SELECT_ALPHA getShaderChannelSelectAlpha(void) const {
return static_cast<SHADER_CHANNEL_SELECT_ALPHA>(TheStructure.Common.ShaderChannelSelectAlpha);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha);
}
inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT_BLUE value) {
inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectBlue = value;
}
inline SHADER_CHANNEL_SELECT_BLUE getShaderChannelSelectBlue(void) const {
return static_cast<SHADER_CHANNEL_SELECT_BLUE>(TheStructure.Common.ShaderChannelSelectBlue);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue);
}
inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT_GREEN value) {
inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectGreen = value;
}
inline SHADER_CHANNEL_SELECT_GREEN getShaderChannelSelectGreen(void) const {
return static_cast<SHADER_CHANNEL_SELECT_GREEN>(TheStructure.Common.ShaderChannelSelectGreen);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen);
}
inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT_RED value) {
inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectRed = value;
}
inline SHADER_CHANNEL_SELECT_RED getShaderChannelSelectRed(void) const {
return static_cast<SHADER_CHANNEL_SELECT_RED>(TheStructure.Common.ShaderChannelSelectRed);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed);
}
inline void setAlphaClearColor(const ALPHA_CLEAR_COLOR value) {
TheStructure.Common.AlphaClearColor = value;

72
core/gen9/hw_cmds_generated.inl
View File

@ -2510,38 +2510,14 @@ typedef struct tagRENDER_SURFACE_STATE {
AUXILIARY_SURFACE_MODE_AUX_HIZ = 0x3,
AUXILIARY_SURFACE_MODE_AUX_CCS_E = 0x5,
} AUXILIARY_SURFACE_MODE;
typedef enum tagSHADER_CHANNEL_SELECT_ALPHA {
SHADER_CHANNEL_SELECT_ALPHA_ZERO = 0x0,
SHADER_CHANNEL_SELECT_ALPHA_ONE = 0x1,
SHADER_CHANNEL_SELECT_ALPHA_RED = 0x4,
SHADER_CHANNEL_SELECT_ALPHA_GREEN = 0x5,
SHADER_CHANNEL_SELECT_ALPHA_BLUE = 0x6,
SHADER_CHANNEL_SELECT_ALPHA_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_ALPHA;
typedef enum tagSHADER_CHANNEL_SELECT_BLUE {
SHADER_CHANNEL_SELECT_BLUE_ZERO = 0x0,
SHADER_CHANNEL_SELECT_BLUE_ONE = 0x1,
SHADER_CHANNEL_SELECT_BLUE_RED = 0x4,
SHADER_CHANNEL_SELECT_BLUE_GREEN = 0x5,
SHADER_CHANNEL_SELECT_BLUE_BLUE = 0x6,
SHADER_CHANNEL_SELECT_BLUE_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_BLUE;
typedef enum tagSHADER_CHANNEL_SELECT_GREEN {
SHADER_CHANNEL_SELECT_GREEN_ZERO = 0x0,
SHADER_CHANNEL_SELECT_GREEN_ONE = 0x1,
SHADER_CHANNEL_SELECT_GREEN_RED = 0x4,
SHADER_CHANNEL_SELECT_GREEN_GREEN = 0x5,
SHADER_CHANNEL_SELECT_GREEN_BLUE = 0x6,
SHADER_CHANNEL_SELECT_GREEN_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_GREEN;
typedef enum tagSHADER_CHANNEL_SELECT_RED {
SHADER_CHANNEL_SELECT_RED_ZERO = 0x0,
SHADER_CHANNEL_SELECT_RED_ONE = 0x1,
SHADER_CHANNEL_SELECT_RED_RED = 0x4,
SHADER_CHANNEL_SELECT_RED_GREEN = 0x5,
SHADER_CHANNEL_SELECT_RED_BLUE = 0x6,
SHADER_CHANNEL_SELECT_RED_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT_RED;
typedef enum tagSHADER_CHANNEL_SELECT {
SHADER_CHANNEL_SELECT_ZERO = 0x0,
SHADER_CHANNEL_SELECT_ONE = 0x1,
SHADER_CHANNEL_SELECT_RED = 0x4,
SHADER_CHANNEL_SELECT_GREEN = 0x5,
SHADER_CHANNEL_SELECT_BLUE = 0x6,
SHADER_CHANNEL_SELECT_ALPHA = 0x7,
} SHADER_CHANNEL_SELECT;
typedef enum tagMEMORY_COMPRESSION_MODE {
MEMORY_COMPRESSION_MODE_HORIZONTAL = 0x0,
MEMORY_COMPRESSION_MODE_VERTICAL = 0x1,
@ -2562,10 +2538,10 @@ typedef struct tagRENDER_SURFACE_STATE {
TheStructure.Common.SurfaceType = SURFACE_TYPE_SURFTYPE_1D;
TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT;
TheStructure.Common.TiledResourceMode = TILED_RESOURCE_MODE_NONE;
TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ALPHA_ZERO;
TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_BLUE_ZERO;
TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_GREEN_ZERO;
TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_RED_ZERO;
TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_ZERO;
TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL;
TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples = NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1;
TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat = MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS;
@ -2776,29 +2752,29 @@ typedef struct tagRENDER_SURFACE_STATE {
inline uint32_t getResourceMinLod(void) const {
return (TheStructure.Common.ResourceMinLod);
}
inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT_ALPHA value) {
inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectAlpha = value;
}
inline SHADER_CHANNEL_SELECT_ALPHA getShaderChannelSelectAlpha(void) const {
return static_cast<SHADER_CHANNEL_SELECT_ALPHA>(TheStructure.Common.ShaderChannelSelectAlpha);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha);
}
inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT_BLUE value) {
inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectBlue = value;
}
inline SHADER_CHANNEL_SELECT_BLUE getShaderChannelSelectBlue(void) const {
return static_cast<SHADER_CHANNEL_SELECT_BLUE>(TheStructure.Common.ShaderChannelSelectBlue);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue);
}
inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT_GREEN value) {
inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectGreen = value;
}
inline SHADER_CHANNEL_SELECT_GREEN getShaderChannelSelectGreen(void) const {
return static_cast<SHADER_CHANNEL_SELECT_GREEN>(TheStructure.Common.ShaderChannelSelectGreen);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen);
}
inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT_RED value) {
inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) {
TheStructure.Common.ShaderChannelSelectRed = value;
}
inline SHADER_CHANNEL_SELECT_RED getShaderChannelSelectRed(void) const {
return static_cast<SHADER_CHANNEL_SELECT_RED>(TheStructure.Common.ShaderChannelSelectRed);
inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed(void) const {
return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed);
}
inline void setMemoryCompressionEnable(const bool value) {
TheStructure.Common.MemoryCompressionEnable = value;

18
runtime/mem_obj/image.h
View File

@ -316,22 +316,22 @@ class ImageHw : public Image {
static int getShaderChannelValue(int inputShaderChannel, cl_channel_order imageChannelOrder) {
if (imageChannelOrder == CL_A) {
if (inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED ||
inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN ||
inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE) {
return RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO;
if (inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED ||
inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN ||
inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE) {
return RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
}
} else if (imageChannelOrder == CL_R ||
imageChannelOrder == CL_RA ||
imageChannelOrder == CL_Rx) {
if (inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN ||
inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE) {
return RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO;
if (inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN ||
inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE) {
return RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
}
} else if (imageChannelOrder == CL_RG ||
imageChannelOrder == CL_RGx) {
if (inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE) {
return RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO;
if (inputShaderChannel == RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE) {
return RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
}
}
return inputShaderChannel;

20
runtime/mem_obj/image.inl
View File

@ -106,23 +106,23 @@ void ImageHw<GfxFamily>::setImageArg(void *memory, bool setAsMediaBlockImage, ui
surfaceState->setSurfaceArray(isImageArray);
cl_channel_order imgChannelOrder = getSurfaceFormatInfo().OCLImageFormat.image_channel_order;
int shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, imgChannelOrder);
surfaceState->setShaderChannelSelectRed(static_cast<typename RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED>(shaderChannelValue));
int shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, imgChannelOrder);
surfaceState->setShaderChannelSelectRed(static_cast<typename RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT>(shaderChannelValue));
if (imgChannelOrder == CL_LUMINANCE) {
surfaceState->setShaderChannelSelectGreen(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN_RED);
surfaceState->setShaderChannelSelectBlue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_RED);
surfaceState->setShaderChannelSelectGreen(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED);
surfaceState->setShaderChannelSelectBlue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED);
} else {
shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN_GREEN, imgChannelOrder);
surfaceState->setShaderChannelSelectGreen(static_cast<typename RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN>(shaderChannelValue));
shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_BLUE, imgChannelOrder);
surfaceState->setShaderChannelSelectBlue(static_cast<typename RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE>(shaderChannelValue));
shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN, imgChannelOrder);
surfaceState->setShaderChannelSelectGreen(static_cast<typename RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT>(shaderChannelValue));
shaderChannelValue = ImageHw<GfxFamily>::getShaderChannelValue(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE, imgChannelOrder);
surfaceState->setShaderChannelSelectBlue(static_cast<typename RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT>(shaderChannelValue));
}
if (IsNV12Image(&this->getImageFormat())) {
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ONE);
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ONE);
} else {
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ALPHA);
surfaceState->setShaderChannelSelectAlpha(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA);
}
surfaceState->setSurfaceHorizontalAlignment(hAlign);

154
unit_tests/mem_obj/image_set_arg_tests.cpp
View File

@ -45,22 +45,22 @@ class ImageSetArgTest : public DeviceFixture,
void SetupChannels(int imgChannelOrder) {
typedef typename FamilyType::RENDER_SURFACE_STATE RENDER_SURFACE_STATE;
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN_GREEN;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_BLUE;
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
if (imgChannelOrder == CL_A) {
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_ZERO;
expectedChannelRed = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
} else if (imgChannelOrder == CL_RA ||
imgChannelOrder == CL_R ||
imgChannelOrder == CL_Rx) {
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_ZERO;
expectedChannelGreen = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
} else if (imgChannelOrder == CL_RG ||
imgChannelOrder == CL_RGx) {
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_ZERO;
expectedChannelBlue = RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO;
}
}
@ -351,7 +351,7 @@ HWTEST_F(ImageSetArgTest, clSetKernelArgImage) {
EXPECT_EQ(expectedChannelRed, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(expectedChannelGreen, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(expectedChannelBlue, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(imageMocs, surfaceState->getMemoryObjectControlState());
std::vector<Surface *> surfaces;
@ -423,7 +423,7 @@ HWTEST_F(ImageSetArgTest, clSetKernelArgImage2Darray) {
EXPECT_EQ(expectedChannelRed, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(expectedChannelGreen, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(expectedChannelBlue, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, surfaceState->getShaderChannelSelectAlpha());
std::vector<Surface *> surfaces;
pKernel->getResidency(surfaces);
@ -470,7 +470,7 @@ HWTEST_F(ImageSetArgTest, clSetKernelArgImage1Darray) {
EXPECT_EQ(expectedChannelRed, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(expectedChannelGreen, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(expectedChannelBlue, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, surfaceState->getShaderChannelSelectAlpha());
std::vector<Surface *> surfaces;
pKernel->getResidency(surfaces);
@ -781,10 +781,10 @@ HWTEST_F(ImageSetArgTest, clSetKernelArgImage1Dbuffer) {
EXPECT_EQ(RENDER_SURFACE_STATE::SURFACE_TYPE_SURFTYPE_BUFFER, surfaceState->getSurfaceType());
EXPECT_FALSE((GFX3DSTATE_SURFACEFORMAT)surfaceState->getSurfaceArray());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN_GREEN, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_BLUE, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, surfaceState->getShaderChannelSelectAlpha());
clReleaseMemObject(imageFromBuffer);
clReleaseMemObject(buffer);
@ -807,10 +807,10 @@ HWTEST_F(ImageSetArgTest, clSetKernelArgImageWithCLLuminanceFormat) {
ptrOffset(pKernel->getSurfaceStateHeap(),
pKernelInfo->kernelArgInfo[0].offsetHeap));
//for CL_LUMINANCE format we override channels to RED to be spec complaint.
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN_RED, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE_RED, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, surfaceState->getShaderChannelSelectAlpha());
std::vector<Surface *> surfaces;
pKernel->getResidency(surfaces);
@ -953,7 +953,7 @@ HWTEST_F(ImageMediaBlockSetArgTest, clSetKernelArgImage) {
EXPECT_EQ(expectedChannelRed, surfaceState->getShaderChannelSelectRed());
EXPECT_EQ(expectedChannelGreen, surfaceState->getShaderChannelSelectGreen());
EXPECT_EQ(expectedChannelBlue, surfaceState->getShaderChannelSelectBlue());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, surfaceState->getShaderChannelSelectAlpha());
EXPECT_EQ(imageMocs, surfaceState->getMemoryObjectControlState());
std::vector<Surface *> surfaces;
@ -973,19 +973,19 @@ HWTEST_F(ImageShaderChanelValueTest, ChannelA) {
int outputChannel = 0;
int inputChannel = 0;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_A);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_A);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_A);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_A);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, outputChannel);
}
HWTEST_F(ImageShaderChanelValueTest, ChannelRA) {
@ -994,47 +994,47 @@ HWTEST_F(ImageShaderChanelValueTest, ChannelRA) {
int outputChannel = 0;
int inputChannel = 0;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_R);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_R);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_R);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_R);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_Rx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_Rx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_Rx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_Rx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, outputChannel);
}
HWTEST_F(ImageShaderChanelValueTest, ChannelRGA) {
@ -1043,33 +1043,33 @@ HWTEST_F(ImageShaderChanelValueTest, ChannelRGA) {
int outputChannel = 0;
int inputChannel = 0;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RG);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RG);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RG);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RG);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ZERO, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ZERO, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGx);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN, outputChannel);
}
HWTEST_F(ImageShaderChanelValueTest, ChannelRGBA) {
@ -1078,18 +1078,18 @@ HWTEST_F(ImageShaderChanelValueTest, ChannelRGBA) {
int outputChannel = 0;
int inputChannel = 0;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA;
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGBA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGBA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGBA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_GREEN, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE;
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_GREEN, outputChannel);
inputChannel = SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE;
outputChannel = ImageHw<FamilyType>::getShaderChannelValue(inputChannel, CL_RGBA);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_RED_BLUE, outputChannel);
EXPECT_EQ(SURFACE_STATE::SHADER_CHANNEL_SELECT_BLUE, outputChannel);
}
HWTEST_F(ImageSetArgTest, givenImageWithOffsetGreaterThan4GBWhenSurfaceStateIsProgrammedThenCorrectStataBaseAddressIsSet) {

2
unit_tests/mem_obj/nv12_image_tests.cpp
View File

@ -417,7 +417,7 @@ HWTEST_F(Nv12ImageTest, setImageArg) {
EXPECT_EQ(surfaceOffsets.yOffsetForUVplane, surfaceState.getYOffsetForUOrUvPlane());
// NV 12 image has correct alpha channel == one
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ALPHA_ONE, surfaceState.getShaderChannelSelectAlpha());
EXPECT_EQ(RENDER_SURFACE_STATE::SHADER_CHANNEL_SELECT_ONE, surfaceState.getShaderChannelSelectAlpha());
delete image;
}