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

Revert "Return error when image arg does not support media block commands" 

This reverts commit 8388e6cf4a.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation 2022-08-24 05:46:39 +02:00 committed by Compute-Runtime-Automation
parent 54041d0f2f
commit a5b4a13452
9 changed files with 9 additions and 363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
level_zero/core/source/kernel/kernel_imp.cpp
View File

@ -18,7 +18,6 @@
#include "shared/source/helpers/ray_tracing_helper.h"
#include "shared/source/helpers/register_offsets.h"
#include "shared/source/helpers/string.h"
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/source/kernel/implicit_args.h"
#include "shared/source/kernel/kernel_arg_descriptor.h"
@ -662,11 +661,6 @@ ze_result_t KernelImp::setArgImage(uint32_t argIndex, size_t argSize, const void
const auto &arg = kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex].as<NEO::ArgDescImage>();
const auto image = Image::fromHandle(*static_cast<const ze_image_handle_t *>(argVal));
auto surfFormat = image->getImageInfo().surfaceFormat->GenxSurfaceFormat;
if (isMediaBlockImage && !NEO::SupportedMediaFormatsHelper::isMediaFormatSupported(surfFormat)) {
return ZE_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT;
}
if (kernelImmData->getDescriptor().kernelAttributes.imageAddressingMode == NEO::KernelDescriptor::Bindless) {
image->copySurfaceStateToSSH(patchBindlessSurfaceState(image->getAllocation(), arg.bindless), 0u, isMediaBlockImage);
} else {

39
level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp
View File

@ -2204,7 +2204,6 @@ HWTEST2_F(SetKernelArg, givenImageAndBindfulKernelWhenSetArgImageThenCopySurface
template <GFXCORE_FAMILY gfxCoreFamily>
struct MyMockImageMediaBlock : public WhiteBox<::L0::ImageCoreFamily<gfxCoreFamily>> {
using WhiteBox<::L0::ImageCoreFamily<gfxCoreFamily>>::imgInfo;
void copySurfaceStateToSSH(void *surfaceStateHeap, const uint32_t surfaceStateOffset, bool isMediaBlockArg) override {
isMediaBlockPassedValue = isMediaBlockArg;
}
@ -2249,44 +2248,6 @@ HWTEST2_F(SetKernelArg, givenSupportsMediaBlockAndIsMediaBlockImageWhenSetArgIma
}
}
HWTEST2_F(SetKernelArg, givenSupportsMediaBlockAndIsMediaBlockImagehaveUnsuportedMediaBlockFormatThenSetArgReturnErrCode, ImageSupport) {
auto hwInfo = device->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
createKernel();
auto argIndex = 3u;
auto &arg = const_cast<NEO::ArgDescriptor &>(kernel->kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex]);
auto imageHW = std::make_unique<MyMockImageMediaBlock<gfxCoreFamily>>();
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
auto ret = imageHW->initialize(device, &desc);
ASSERT_EQ(ZE_RESULT_SUCCESS, ret);
auto handle = imageHW->toHandle();
hwInfo->capabilityTable.supportsMediaBlock = true;
arg.getExtendedTypeInfo().isMediaBlockImage = true;
SurfaceFormatInfo surfInfo = {GMM_FORMAT_R32G32B32A32_FLOAT_TYPE, NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT, 0, 4, 4, 16};
imageHW.get()->imgInfo.surfaceFormat = &surfInfo;
EXPECT_EQ(kernel->setArgImage(argIndex, sizeof(imageHW.get()), &handle), ZE_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT);
}
HWTEST2_F(SetKernelArg, givenSupportsMediaBlockAndIsMediaBlockImagehaveSuportedMediaBlockFormatThenSetArgReturnSuccess, ImageSupport) {
auto hwInfo = device->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo();
createKernel();
auto argIndex = 3u;
auto &arg = const_cast<NEO::ArgDescriptor &>(kernel->kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex]);
auto imageHW = std::make_unique<MyMockImageMediaBlock<gfxCoreFamily>>();
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
auto ret = imageHW->initialize(device, &desc);
ASSERT_EQ(ZE_RESULT_SUCCESS, ret);
auto handle = imageHW->toHandle();
hwInfo->capabilityTable.supportsMediaBlock = true;
arg.getExtendedTypeInfo().isMediaBlockImage = true;
SurfaceFormatInfo surfInfo = {GMM_FORMAT_Y216, NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM, 0, 4, 2, 8};
imageHW.get()->imgInfo.surfaceFormat = &surfInfo;
EXPECT_EQ(kernel->setArgImage(argIndex, sizeof(imageHW.get()), &handle), ZE_RESULT_SUCCESS);
}
using ImportHostPointerSetKernelArg = Test<ImportHostPointerModuleFixture>;
TEST_F(ImportHostPointerSetKernelArg, givenHostPointerImportedWhenSettingKernelArgThenUseHostPointerAllocation) {
createKernel();

5
opencl/source/kernel/kernel.cpp
View File

@ -20,7 +20,6 @@
#include "shared/source/helpers/kernel_helpers.h"
#include "shared/source/helpers/per_thread_data.h"
#include "shared/source/helpers/ptr_math.h"
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/source/kernel/kernel_arg_descriptor_extended_vme.h"
#include "shared/source/memory_manager/memory_manager.h"
@ -1553,10 +1552,6 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex,
auto pImage = castToObject<Image>(clMemObj);
if (pImage && argSize == sizeof(cl_mem *)) {
auto surfFormat = pImage->getSurfaceFormatInfo().surfaceFormat.GenxSurfaceFormat;
if (arg.getExtendedTypeInfo().isMediaBlockImage && !SupportedMediaFormatsHelper::isMediaFormatSupported(surfFormat)) {
return CL_INVALID_ARG_VALUE;
}
if (pImage->peekSharingHandler()) {
usingSharedObjArgs = true;
}

24
opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp
View File

@ -995,30 +995,6 @@ HWTEST_F(ImageMediaBlockSetArgTest, WhenSettingKernelArgImageThenPropertiesAreCo
}
}
TEST_F(ImageMediaBlockSetArgTest, givenKernelWithMediaBlockOperationWhenSupportedFormatPassedThenSetKernelArgReturnSuccess) {
const_cast<ClSurfaceFormatInfo &>(srcImage->getSurfaceFormatInfo()).surfaceFormat.GenxSurfaceFormat = NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM;
cl_mem memObj = srcImage;
retVal = clSetKernelArg(
pMultiDeviceKernel,
0,
sizeof(memObj),
&memObj);
ASSERT_EQ(CL_SUCCESS, retVal);
}
TEST_F(ImageMediaBlockSetArgTest, givenKernelWithMediaBlockOperationWhenUnSupportedFormatPassedThenSetKernelArgReturnErrCode) {
const_cast<ClSurfaceFormatInfo &>(srcImage->getSurfaceFormatInfo()).surfaceFormat.GenxSurfaceFormat = NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT;
cl_mem memObj = srcImage;
retVal = clSetKernelArg(
pMultiDeviceKernel,
0,
sizeof(memObj),
&memObj);
ASSERT_EQ(CL_INVALID_ARG_VALUE, retVal);
}
typedef ImageSetArgTest ImageShaderChannelValueTest;
HWTEST_F(ImageShaderChannelValueTest, GivenChannelAWhenGettingShaderChannelValueThenOutputChannelIsCorrect) {

2
shared/source/helpers/CMakeLists.txt
View File

@ -128,8 +128,6 @@ set(NEO_CORE_HELPERS
${CMAKE_CURRENT_SOURCE_DIR}/stdio.h
${CMAKE_CURRENT_SOURCE_DIR}/string.h
${CMAKE_CURRENT_SOURCE_DIR}/string_helpers.h
${CMAKE_CURRENT_SOURCE_DIR}/supported_media_surface_formats.cpp
${CMAKE_CURRENT_SOURCE_DIR}/supported_media_surface_formats.h
${CMAKE_CURRENT_SOURCE_DIR}/surface_format_info.h
${CMAKE_CURRENT_SOURCE_DIR}/timestamp_packet.cpp
${CMAKE_CURRENT_SOURCE_DIR}/timestamp_packet.h

61
shared/source/helpers/supported_media_surface_formats.cpp
View File

@ -1,61 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include <algorithm>
#include <array>
namespace NEO {
constexpr std::array<NEO::GFX3DSTATE_SURFACEFORMAT, 42> supportedMediaSurfaceFormats = {NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R11G11B10_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_R32_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R32_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R32_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R16_FLOAT,
NEO::GFX3DSTATE_SURFACEFORMAT_A16_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_SNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_SINT,
NEO::GFX3DSTATE_SURFACEFORMAT_R8_UINT,
NEO::GFX3DSTATE_SURFACEFORMAT_A8_UNORM,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV,
NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY,
NEO::GFX3DSTATE_SURFACEFORMAT_PACKED_422_16};
bool SupportedMediaFormatsHelper::isMediaFormatSupported(NEO::GFX3DSTATE_SURFACEFORMAT format) {
return std::find(NEO::supportedMediaSurfaceFormats.begin(), NEO::supportedMediaSurfaceFormats.end(), format) != NEO::supportedMediaSurfaceFormats.end();
}
} // namespace NEO

16
shared/source/helpers/supported_media_surface_formats.h
View File

@ -1,16 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
namespace NEO {
enum GFX3DSTATE_SURFACEFORMAT : unsigned short;
class SupportedMediaFormatsHelper {
public:
static bool isMediaFormatSupported(GFX3DSTATE_SURFACEFORMAT format);
};
} // namespace NEO

1
shared/test/unit_test/helpers/CMakeLists.txt
View File

@ -37,7 +37,6 @@ target_sources(neo_shared_tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/state_base_address_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/string_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/string_to_hash_tests.cpp
${CMAKE_CURRENT_SOURCE_DIR}/supported_media_surface_formats_test.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_debug_variables.inl
${CMAKE_CURRENT_SOURCE_DIR}/test_hw_info_config.cpp
${CMAKE_CURRENT_SOURCE_DIR}/cache_policy_tests.cpp

200
shared/test/unit_test/helpers/supported_media_surface_formats_test.cpp
View File

@ -1,200 +0,0 @@
/*
* Copyright (C) 2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/supported_media_surface_formats.h"
#include "shared/source/helpers/surface_format_info.h"
#include "shared/test/common/test_macros/test.h"
std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool> formatsVithSupportValue[171]{
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64G64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32A32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32B32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_FLOAT_X8X24_TYPELESS, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_X32_TYPELESS_G8X24_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L32A32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16X16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16X16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I32X32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16A16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32G32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8A8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10_SNORM_A2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10A2_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R11G11B10_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R24_UNORM_X8_TYPELESS, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_X24_TYPELESS_G8_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16A16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I24X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L24X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A24X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A32_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B8G8R8X8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8X8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R9G9B9E5_SHAREDEXP, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B10G10R10X2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16A16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10X2_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8A8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R32_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G6R5_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5A1_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B4G4R4A4_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_FLOAT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A16_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8A8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8A8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R5G5_SNORM_B6_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_B5G5R5X1_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_SNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_SINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_UINT, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A8_UNORM, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_I8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_P4A4_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_A4P4_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_P8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_L8_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_Y8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_DXT1_RGB_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R1_UINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_NORMAL, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUVY, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_P2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC1_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC2_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC3_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC4_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC5_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC1_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC2_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC3_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_MONO8, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPUV, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_YCRCB_SWAPY, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_DXT1_RGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_FXT1, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R8G8B8_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64G64B64A64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R64G64B64_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC4_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC5_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_FLOAT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_SSCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R16G16B16_USCALED, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC6H_SF16, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC7_UNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC7_UNORM_SRGB, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_BC6H_UF16, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_PLANAR_420_8, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_PLANAR_420_16, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_PACKED_422_16, true),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_SINT, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_R10G10B10A2_SNORM, false),
std::make_pair(NEO::GFX3DSTATE_SURFACEFORMAT_RAW, false)};
class MediaBlockSupportedFormatsTests : public ::testing::WithParamInterface<std::pair<NEO::GFX3DSTATE_SURFACEFORMAT, bool>>, public ::testing::Test {
public:
void SetUp() override {
}
void TearDown() override {
}
};
INSTANTIATE_TEST_CASE_P(AllFormatsWithMediaBlockSupportValue,
MediaBlockSupportedFormatsTests,
::testing::ValuesIn(formatsVithSupportValue));
TEST_P(MediaBlockSupportedFormatsTests, givenSurfaceFormatWhenIsMediaFormatSupportedThenCorrectValueReturned) {
EXPECT_EQ(NEO::SupportedMediaFormatsHelper::isMediaFormatSupported(GetParam().first), GetParam().second);
}