From e56d18b69f0ed62949da1ff83af5ed7b78f3b2ba Mon Sep 17 00:00:00 2001 From: Maciej Plewka Date: Fri, 30 Sep 2022 14:38:39 +0000 Subject: [PATCH] Return error when image arg does not support media block commands Signed-off-by: Maciej Plewka --- level_zero/core/source/kernel/kernel_imp.cpp | 6 + .../unit_tests/sources/kernel/test_kernel.cpp | 57 +++++- opencl/source/kernel/kernel.cpp | 5 + .../unit_test/mem_obj/image_set_arg_tests.cpp | 24 +++ shared/source/helpers/CMakeLists.txt | 2 + .../supported_media_surface_formats.cpp | 61 ++++++ .../helpers/supported_media_surface_formats.h | 16 ++ shared/test/unit_test/helpers/CMakeLists.txt | 1 + .../supported_media_surface_formats_test.cpp | 193 ++++++++++++++++++ 9 files changed, 356 insertions(+), 9 deletions(-) create mode 100644 shared/source/helpers/supported_media_surface_formats.cpp create mode 100644 shared/source/helpers/supported_media_surface_formats.h create mode 100644 shared/test/unit_test/helpers/supported_media_surface_formats_test.cpp diff --git a/level_zero/core/source/kernel/kernel_imp.cpp b/level_zero/core/source/kernel/kernel_imp.cpp index 5ae0f31b91..acfc0790c3 100644 --- a/level_zero/core/source/kernel/kernel_imp.cpp +++ b/level_zero/core/source/kernel/kernel_imp.cpp @@ -18,6 +18,7 @@ #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" @@ -635,6 +636,11 @@ ze_result_t KernelImp::setArgImage(uint32_t argIndex, size_t argSize, const void const auto &arg = kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex].as(); const auto image = Image::fromHandle(*static_cast(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 { diff --git a/level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp b/level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp index 46b496107e..63a4e9eb47 100644 --- a/level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp +++ b/level_zero/core/test/unit_tests/sources/kernel/test_kernel.cpp @@ -117,48 +117,48 @@ TEST_F(SetKernelArgCacheTest, givenValidBufferArgumentWhenSetMultipleTimesThenSe size_t callCounter = 0u; - //first setArg - called + // first setArg - called EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation)); EXPECT_EQ(++callCounter, mockKernel.setArgBufferWithAllocCalled); - //same setArg but allocationCounter == 0 - called + // same setArg but allocationCounter == 0 - called EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation)); EXPECT_EQ(++callCounter, mockKernel.setArgBufferWithAllocCalled); - //same setArg - not called and argInfo.allocationCounter is updated + // same setArg - not called and argInfo.allocationCounter is updated ++svmAllocsManager->allocationsCounter; EXPECT_EQ(0u, mockKernel.kernelArgInfos[0].allocIdMemoryManagerCounter); EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation)); EXPECT_EQ(callCounter, mockKernel.setArgBufferWithAllocCalled); EXPECT_EQ(svmAllocsManager->allocationsCounter, mockKernel.kernelArgInfos[0].allocIdMemoryManagerCounter); - //same setArg and allocationCounter - not called + // same setArg and allocationCounter - not called EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation)); EXPECT_EQ(callCounter, mockKernel.setArgBufferWithAllocCalled); - //same setArg but different allocId - called + // same setArg but different allocId - called svmAllocsManager->getSVMAlloc(svmAllocation)->setAllocId(1u); ++svmAllocsManager->allocationsCounter; EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(svmAllocation), &svmAllocation)); EXPECT_EQ(++callCounter, mockKernel.setArgBufferWithAllocCalled); - //different value - called + // different value - called auto secondSvmAllocation = svmAllocsManager->createSVMAlloc(4096, allocationProperties, context->rootDeviceIndices, context->deviceBitfields); EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(secondSvmAllocation), &secondSvmAllocation)); EXPECT_EQ(++callCounter, mockKernel.setArgBufferWithAllocCalled); - //nullptr - not called, argInfo is updated + // nullptr - not called, argInfo is updated EXPECT_FALSE(mockKernel.kernelArgInfos[0].isSetToNullptr); EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(nullptr), nullptr)); EXPECT_EQ(callCounter, mockKernel.setArgBufferWithAllocCalled); EXPECT_TRUE(mockKernel.kernelArgInfos[0].isSetToNullptr); - //nullptr again - not called + // nullptr again - not called EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(nullptr), nullptr)); EXPECT_EQ(callCounter, mockKernel.setArgBufferWithAllocCalled); EXPECT_TRUE(mockKernel.kernelArgInfos[0].isSetToNullptr); - //same value as before nullptr - called, argInfo is updated + // same value as before nullptr - called, argInfo is updated EXPECT_EQ(ZE_RESULT_SUCCESS, mockKernel.setArgBuffer(0, sizeof(secondSvmAllocation), &secondSvmAllocation)); EXPECT_EQ(++callCounter, mockKernel.setArgBufferWithAllocCalled); EXPECT_FALSE(mockKernel.kernelArgInfos[0].isSetToNullptr); @@ -2207,6 +2207,7 @@ HWTEST2_F(SetKernelArg, givenImageAndBindfulKernelWhenSetArgImageThenCopySurface template struct MyMockImageMediaBlock : public WhiteBox<::L0::ImageCoreFamily> { + using WhiteBox<::L0::ImageCoreFamily>::imgInfo; void copySurfaceStateToSSH(void *surfaceStateHeap, const uint32_t surfaceStateOffset, bool isMediaBlockArg) override { isMediaBlockPassedValue = isMediaBlockArg; } @@ -2251,6 +2252,44 @@ HWTEST2_F(SetKernelArg, givenSupportsMediaBlockAndIsMediaBlockImageWhenSetArgIma } } +HWTEST2_F(SetKernelArg, givenSupportsMediaBlockAndIsMediaBlockImagehaveUnsuportedMediaBlockFormatThenSetArgReturnErrCode, ImageSupport) { + auto hwInfo = device->getNEODevice()->getRootDeviceEnvironment().getMutableHardwareInfo(); + createKernel(); + auto argIndex = 3u; + auto &arg = const_cast(kernel->kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex]); + auto imageHW = std::make_unique>(); + 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(kernel->kernelImmData->getDescriptor().payloadMappings.explicitArgs[argIndex]); + auto imageHW = std::make_unique>(); + 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; TEST_F(ImportHostPointerSetKernelArg, givenHostPointerImportedWhenSettingKernelArgThenUseHostPointerAllocation) { createKernel(); diff --git a/opencl/source/kernel/kernel.cpp b/opencl/source/kernel/kernel.cpp index 8df5d752d3..743cbde40e 100644 --- a/opencl/source/kernel/kernel.cpp +++ b/opencl/source/kernel/kernel.cpp @@ -20,6 +20,7 @@ #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" @@ -1583,6 +1584,10 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex, auto pImage = castToObject(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; } diff --git a/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp b/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp index 699b8db8bd..7f517f1510 100644 --- a/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp +++ b/opencl/test/unit_test/mem_obj/image_set_arg_tests.cpp @@ -995,6 +995,30 @@ HWTEST_F(ImageMediaBlockSetArgTest, WhenSettingKernelArgImageThenPropertiesAreCo } } +TEST_F(ImageMediaBlockSetArgTest, givenKernelWithMediaBlockOperationWhenSupportedFormatPassedThenSetKernelArgReturnSuccess) { + const_cast(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(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) { diff --git a/shared/source/helpers/CMakeLists.txt b/shared/source/helpers/CMakeLists.txt index ad13c11192..6a7c9a3808 100644 --- a/shared/source/helpers/CMakeLists.txt +++ b/shared/source/helpers/CMakeLists.txt @@ -127,6 +127,8 @@ 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 diff --git a/shared/source/helpers/supported_media_surface_formats.cpp b/shared/source/helpers/supported_media_surface_formats.cpp new file mode 100644 index 0000000000..cc190407c6 --- /dev/null +++ b/shared/source/helpers/supported_media_surface_formats.cpp @@ -0,0 +1,61 @@ +/* + * 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 +#include + +namespace NEO { +constexpr std::array 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 \ No newline at end of file diff --git a/shared/source/helpers/supported_media_surface_formats.h b/shared/source/helpers/supported_media_surface_formats.h new file mode 100644 index 0000000000..6b4303bb03 --- /dev/null +++ b/shared/source/helpers/supported_media_surface_formats.h @@ -0,0 +1,16 @@ +/* + * 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 \ No newline at end of file diff --git a/shared/test/unit_test/helpers/CMakeLists.txt b/shared/test/unit_test/helpers/CMakeLists.txt index fb992e79e6..85c3328376 100644 --- a/shared/test/unit_test/helpers/CMakeLists.txt +++ b/shared/test/unit_test/helpers/CMakeLists.txt @@ -36,6 +36,7 @@ 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 diff --git a/shared/test/unit_test/helpers/supported_media_surface_formats_test.cpp b/shared/test/unit_test/helpers/supported_media_surface_formats_test.cpp new file mode 100644 index 0000000000..be87fe0cfe --- /dev/null +++ b/shared/test/unit_test/helpers/supported_media_surface_formats_test.cpp @@ -0,0 +1,193 @@ +/* + * 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 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)}; + +using MediaBlockSupportedFormatsTests = ::testing::TestWithParam>; + +INSTANTIATE_TEST_CASE_P(AllFormatsWithMediaBlockSupportValue, + MediaBlockSupportedFormatsTests, + ::testing::ValuesIn(formatsVithSupportValue)); + +TEST_P(MediaBlockSupportedFormatsTests, givenSurfaceFormatWhenIsMediaFormatSupportedThenCorrectValueReturned) { + EXPECT_EQ(NEO::SupportedMediaFormatsHelper::isMediaFormatSupported(GetParam().first), GetParam().second); +}