intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 06:49:52 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: adds support for 3 channel (2/N)

Browse Source 
Allows user to create L0 images with 3 channel

Related-To: NEO-12887

Signed-off-by: Kulkarni, Ashwin Kumar <ashwin.kumar.kulkarni@intel.com>
This commit is contained in:
Kulkarni, Ashwin Kumar
2024-12-31 18:37:27 +00:00
committed by Compute-Runtime-Automation
parent f198507875
commit badbecb126
17 changed files with 1409 additions and 804 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
level_zero/core/source/builtin/builtin_functions_lib.h
View File

@@ -57,8 +57,12 @@ enum class ImageBuiltin : uint32_t {
copyBufferToImage3d2BytesHeapless,
copyBufferToImage3d4Bytes,
copyBufferToImage3d4BytesHeapless,
copyBufferToImage3d3To4Bytes,
copyBufferToImage3d3To4BytesHeapless,
copyBufferToImage3d8Bytes,
copyBufferToImage3d8BytesHeapless,
copyBufferToImage3d6To8Bytes,
copyBufferToImage3d6To8BytesHeapless,
copyBufferToImage3dBytes,
copyBufferToImage3dBytesHeapless,
copyImage3dToBuffer16Bytes,
@@ -69,10 +73,14 @@ enum class ImageBuiltin : uint32_t {
copyImage3dToBuffer3BytesHeapless,
copyImage3dToBuffer4Bytes,
copyImage3dToBuffer4BytesHeapless,
copyImage3dToBuffer4To3Bytes,
copyImage3dToBuffer4To3BytesHeapless,
copyImage3dToBuffer6Bytes,
copyImage3dToBuffer6BytesHeapless,
copyImage3dToBuffer8Bytes,
copyImage3dToBuffer8BytesHeapless,
copyImage3dToBuffer8To6Bytes,
copyImage3dToBuffer8To6BytesHeapless,
copyImage3dToBufferBytes,
copyImage3dToBufferBytesHeapless,
copyImageRegion,
@@ -200,14 +208,18 @@ constexpr ImageBuiltin adjustImageBuiltinType(const bool isHeapless) {
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyBufferToImage3d16Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyBufferToImage3d2Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyBufferToImage3d4Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyBufferToImage3d3To4Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyBufferToImage3d8Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyBufferToImage3d6To8Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyBufferToImage3dBytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer16Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer2Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer3Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer4Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer4To3Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer6Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer8Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBuffer8To6Bytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImage3dToBufferBytes);
DEFINE_ADJUST_IMAGE_BUILTIN_TYPE(ImageBuiltin::copyImageRegion);

32
level_zero/core/source/builtin/builtin_functions_lib_impl.cpp
View File

@@ -180,6 +180,14 @@ void BuiltinFunctionsLibImpl::initBuiltinImageKernel(ImageBuiltin func) {
builtinName = "CopyBufferToImage3d4BytesStateless";
builtin = NEO::EBuiltInOps::copyBufferToImage3dHeapless;
break;
case ImageBuiltin::copyBufferToImage3d3To4Bytes:
builtinName = "CopyBufferToImage3d3To4Bytes";
builtin = NEO::EBuiltInOps::copyBufferToImage3d;
break;
case ImageBuiltin::copyBufferToImage3d3To4BytesHeapless:
builtinName = "CopyBufferToImage3d3To4BytesStateless";
builtin = NEO::EBuiltInOps::copyBufferToImage3dHeapless;
break;
case ImageBuiltin::copyBufferToImage3d8Bytes:
builtinName = "CopyBufferToImage3d8Bytes";
builtin = NEO::EBuiltInOps::copyBufferToImage3d;
@@ -188,6 +196,14 @@ void BuiltinFunctionsLibImpl::initBuiltinImageKernel(ImageBuiltin func) {
builtinName = "CopyBufferToImage3d8BytesStateless";
builtin = NEO::EBuiltInOps::copyBufferToImage3dHeapless;
break;
case ImageBuiltin::copyBufferToImage3d6To8Bytes:
builtinName = "CopyBufferToImage3d6To8Bytes";
builtin = NEO::EBuiltInOps::copyBufferToImage3d;
break;
case ImageBuiltin::copyBufferToImage3d6To8BytesHeapless:
builtinName = "CopyBufferToImage3d6To8BytesStateless";
builtin = NEO::EBuiltInOps::copyBufferToImage3dHeapless;
break;
case ImageBuiltin::copyBufferToImage3dBytes:
builtinName = "CopyBufferToImage3dBytes";
builtin = NEO::EBuiltInOps::copyBufferToImage3d;
@@ -228,6 +244,14 @@ void BuiltinFunctionsLibImpl::initBuiltinImageKernel(ImageBuiltin func) {
builtinName = "CopyImage3dToBuffer4BytesStateless";
builtin = NEO::EBuiltInOps::copyImage3dToBufferHeapless;
break;
case ImageBuiltin::copyImage3dToBuffer4To3Bytes:
builtinName = "CopyImage3dToBuffer4To3Bytes";
builtin = NEO::EBuiltInOps::copyImage3dToBuffer;
break;
case ImageBuiltin::copyImage3dToBuffer4To3BytesHeapless:
builtinName = "CopyImage3dToBuffer4To3BytesStateless";
builtin = NEO::EBuiltInOps::copyImage3dToBufferHeapless;
break;
case ImageBuiltin::copyImage3dToBuffer6Bytes:
builtinName = "CopyImage3dToBuffer6Bytes";
builtin = NEO::EBuiltInOps::copyImage3dToBuffer;
@@ -244,6 +268,14 @@ void BuiltinFunctionsLibImpl::initBuiltinImageKernel(ImageBuiltin func) {
builtinName = "CopyImage3dToBuffer8BytesStateless";
builtin = NEO::EBuiltInOps::copyImage3dToBufferHeapless;
break;
case ImageBuiltin::copyImage3dToBuffer8To6Bytes:
builtinName = "CopyImage3dToBuffer8To6Bytes";
builtin = NEO::EBuiltInOps::copyImage3dToBuffer;
break;
case ImageBuiltin::copyImage3dToBuffer8To6BytesHeapless:
builtinName = "CopyImage3dToBuffer8To6BytesStateless";
builtin = NEO::EBuiltInOps::copyImage3dToBufferHeapless;
break;
case ImageBuiltin::copyImage3dToBufferBytes:
builtinName = "CopyImage3dToBufferBytes";
builtin = NEO::EBuiltInOps::copyImage3dToBuffer;

57
level_zero/core/source/cmdlist/cmdlist_hw.inl
View File

@@ -695,7 +695,6 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemoryExt(z
auto image = Image::fromHandle(hDstImage);
auto bytesPerPixel = static_cast<uint32_t>(image->getImageInfo().surfaceFormat->imageElementSizeInBytes);
Vec3<size_t> imgSize = {image->getImageDesc().width,
image->getImageDesc().height,
image->getImageDesc().depth};
@@ -718,7 +717,18 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemoryExt(z
}
if (srcRowPitch == 0) {
srcRowPitch = pDstRegion->width * bytesPerPixel;
if (image->isMimickedImage()) {
uint32_t srcBytesPerPixel = bytesPerPixel;
if (bytesPerPixel == 8) {
srcBytesPerPixel = 6;
}
if (bytesPerPixel == 4) {
srcBytesPerPixel = 3;
}
srcRowPitch = pDstRegion->width * srcBytesPerPixel;
} else {
srcRowPitch = pDstRegion->width * bytesPerPixel;
}
}
if (srcSlicePitch == 0) {
srcSlicePitch = (image->getImageInfo().imgDesc.imageType == NEO::ImageType::image1DArray ? 1 : pDstRegion->height) * srcRowPitch;
@@ -743,6 +753,9 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemoryExt(z
}
if (isCopyOnly(false)) {
if ((bytesPerPixel == 3) || (bytesPerPixel == 6) || image->isMimickedImage()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
size_t imgRowPitch = image->getImageInfo().rowPitch;
size_t imgSlicePitch = image->getImageInfo().slicePitch;
auto status = appendCopyImageBlit(allocationStruct.alloc, image->getAllocation(),
@@ -763,10 +776,18 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyFromMemoryExt(z
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d2Bytes>(isHeaplessEnabled);
break;
case 4u:
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d4Bytes>(isHeaplessEnabled);
if (image->isMimickedImage()) {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d3To4Bytes>(isHeaplessEnabled);
} else {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d4Bytes>(isHeaplessEnabled);
}
break;
case 8u:
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d8Bytes>(isHeaplessEnabled);
if (image->isMimickedImage()) {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d6To8Bytes>(isHeaplessEnabled);
} else {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d8Bytes>(isHeaplessEnabled);
}
break;
case 16u:
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyBufferToImage3d16Bytes>(isHeaplessEnabled);
@@ -868,7 +889,6 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemoryExt(voi
auto image = Image::fromHandle(hSrcImage);
auto bytesPerPixel = static_cast<uint32_t>(image->getImageInfo().surfaceFormat->imageElementSizeInBytes);
Vec3<size_t> imgSize = {image->getImageDesc().width,
image->getImageDesc().height,
image->getImageDesc().depth};
@@ -891,7 +911,18 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemoryExt(voi
}
if (destRowPitch == 0) {
destRowPitch = pSrcRegion->width * bytesPerPixel;
if (image->isMimickedImage()) {
uint32_t destBytesPerPixel = bytesPerPixel;
if (bytesPerPixel == 8) {
destBytesPerPixel = 6;
}
if (bytesPerPixel == 4) {
destBytesPerPixel = 3;
}
destRowPitch = pSrcRegion->width * destBytesPerPixel;
} else {
destRowPitch = pSrcRegion->width * bytesPerPixel;
}
}
if (destSlicePitch == 0) {
destSlicePitch = (image->getImageInfo().imgDesc.imageType == NEO::ImageType::image1DArray ? 1 : pSrcRegion->height) * destRowPitch;
@@ -916,7 +947,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemoryExt(voi
}
if (isCopyOnly(false)) {
if ((bytesPerPixel == 3) || (bytesPerPixel == 6)) {
if ((bytesPerPixel == 3) || (bytesPerPixel == 6) || image->isMimickedImage()) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
size_t imgRowPitch = image->getImageInfo().rowPitch;
@@ -943,13 +974,21 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendImageCopyToMemoryExt(voi
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer3Bytes>(isHeaplessEnabled);
break;
case 4u:
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer4Bytes>(isHeaplessEnabled);
if (image->isMimickedImage()) {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer4To3Bytes>(isHeaplessEnabled);
} else {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer4Bytes>(isHeaplessEnabled);
}
break;
case 6u:
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer6Bytes>(isHeaplessEnabled);
break;
case 8u:
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer8Bytes>(isHeaplessEnabled);
if (image->isMimickedImage()) {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer8To6Bytes>(isHeaplessEnabled);
} else {
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer8Bytes>(isHeaplessEnabled);
}
break;
case 16u:
builtInType = BuiltinTypeHelper::adjustImageBuiltinType<ImageBuiltin::copyImage3dToBuffer16Bytes>(isHeaplessEnabled);

1
level_zero/core/source/image/image.h
View File

@@ -52,6 +52,7 @@ struct Image : _ze_image_handle_t {
virtual ze_result_t allocateBindlessSlot() = 0;
virtual NEO::SurfaceStateInHeapInfo *getBindlessSlot() = 0;
virtual ze_result_t getDeviceOffset(uint64_t *deviceOffset) = 0;
virtual bool isMimickedImage() = 0;
static ze_result_t getPitchFor2dImage(
ze_device_handle_t hDevice,

62
level_zero/core/source/image/image_imp.cpp
View File

@@ -128,6 +128,58 @@ NEO::SurfaceStateInHeapInfo *ImageImp::getBindlessSlot() {
return bindlessInfo.get();
}
bool getImageDescriptor(const ze_image_desc_t *origImgDesc, ze_image_desc_t *imgDesc) {
bool modified = false;
*imgDesc = *origImgDesc;
if (origImgDesc->pNext) {
const ze_base_desc_t *extendedDesc = reinterpret_cast<const ze_base_desc_t *>(origImgDesc->pNext);
if (extendedDesc->stype != ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32) {
switch (origImgDesc->format.layout) {
default:
break;
case ZE_IMAGE_FORMAT_LAYOUT_16_16_16:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
case ZE_IMAGE_FORMAT_LAYOUT_8_8_8:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
}
}
} else {
switch (origImgDesc->format.layout) {
default:
break;
case ZE_IMAGE_FORMAT_LAYOUT_16_16_16:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_16_16_16_16;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
case ZE_IMAGE_FORMAT_LAYOUT_8_8_8:
imgDesc->format.layout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8_8;
imgDesc->format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
imgDesc->format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
imgDesc->format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
imgDesc->format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
modified = true;
break;
}
}
return modified;
}
ze_result_t Image::create(uint32_t productFamily, Device *device, const ze_image_desc_t *desc, Image **pImage) {
ze_result_t result = ZE_RESULT_SUCCESS;
ImageAllocatorFn allocator = nullptr;
@@ -138,7 +190,15 @@ ze_result_t Image::create(uint32_t productFamily, Device *device, const ze_image
ImageImp *image = nullptr;
if (allocator) {
image = static_cast<ImageImp *>((*allocator)());
result = image->initialize(device, desc);
ze_image_desc_t imgDesc = {};
bool modified = getImageDescriptor(desc, &imgDesc);
if (modified) {
image->setMimickedImage(true);
result = image->initialize(device, &imgDesc);
} else {
result = image->initialize(device, desc);
}
if (result != ZE_RESULT_SUCCESS) {
image->destroy();
image = nullptr;

9
level_zero/core/source/image/image_imp.h
View File

@@ -46,6 +46,14 @@ struct ImageImp : public Image, NEO::NonCopyableOrMovableClass {
return sourceImageFormatDesc.has_value();
}
bool isMimickedImage() override {
return mimickedImagefor3Ch;
}
void setMimickedImage(bool value) {
this->mimickedImagefor3Ch = value;
}
ze_result_t allocateBindlessSlot() override;
NEO::SurfaceStateInHeapInfo *getBindlessSlot() override;
ze_result_t getDeviceOffset(uint64_t *deviceOffset) override;
@@ -63,5 +71,6 @@ struct ImageImp : public Image, NEO::NonCopyableOrMovableClass {
bool bindlessImage = false;
bool imageFromBuffer = false;
bool sampledImage = false;
bool mimickedImagefor3Ch = false;
};
} // namespace L0

131
level_zero/core/test/unit_tests/sources/image/test_image.cpp
View File

@@ -2384,5 +2384,136 @@ HWTEST2_F(ImageCreate, given2DImageFormatWithPixelSizeOf6BytesWhenRowPitchIsQuer
EXPECT_EQ(rowPitch, imageHW->imgInfo.rowPitch);
}
HWTEST2_F(ImageCreate, givenValidImageDescriptionFor3ChannelWhenImageCreateThenImageIsCreatedCorrectly, MatchAny) {
ze_image_desc_t zeDesc = {};
zeDesc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
zeDesc.arraylevels = 1u;
zeDesc.depth = 1u;
zeDesc.height = 1u;
zeDesc.width = 100u;
zeDesc.miplevels = 1u;
zeDesc.type = ZE_IMAGE_TYPE_2DARRAY;
zeDesc.flags = ZE_IMAGE_FLAG_BIAS_UNCACHED;
zeDesc.format = {ZE_IMAGE_FORMAT_LAYOUT_8_8_8,
ZE_IMAGE_FORMAT_TYPE_UNORM,
ZE_IMAGE_FORMAT_SWIZZLE_R,
ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_1};
Image *imagePtr;
auto result = Image::create(productFamily, device, &zeDesc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
std::unique_ptr<L0::Image> image(imagePtr);
ASSERT_NE(image, nullptr);
}
HWTEST2_F(ImageCreate, givenValidImageDescriptionFor3Channel16BitFloatWhenImageCreateThenImageIsCreatedCorrectly, MatchAny) {
ze_image_desc_t zeDesc = {};
zeDesc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
zeDesc.arraylevels = 1u;
zeDesc.depth = 1u;
zeDesc.height = 1u;
zeDesc.width = 100u;
zeDesc.miplevels = 1u;
zeDesc.type = ZE_IMAGE_TYPE_2DARRAY;
zeDesc.flags = ZE_IMAGE_FLAG_BIAS_UNCACHED;
zeDesc.format = {ZE_IMAGE_FORMAT_LAYOUT_16_16_16,
ZE_IMAGE_FORMAT_TYPE_FLOAT,
ZE_IMAGE_FORMAT_SWIZZLE_R,
ZE_IMAGE_FORMAT_SWIZZLE_G,
ZE_IMAGE_FORMAT_SWIZZLE_B,
ZE_IMAGE_FORMAT_SWIZZLE_1};
Image *imagePtr;
auto result = Image::create(productFamily, device, &zeDesc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
std::unique_ptr<L0::Image> image(imagePtr);
ASSERT_NE(image, nullptr);
}
HWTEST2_F(ImageCreateExternalMemoryTest, givenNTHandleWhenCreatingInteropImageThenSuccessIsReturned, MatchAny) {
ze_external_memory_import_win32_handle_t importNTHandle = {};
importNTHandle.handle = &imageHandle;
importNTHandle.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_OPAQUE_WIN32;
importNTHandle.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_WIN32;
desc.pNext = &importNTHandle;
delete driverHandle->svmAllocsManager;
driverHandle->setMemoryManager(execEnv->memoryManager.get());
driverHandle->svmAllocsManager = new NEO::SVMAllocsManager(execEnv->memoryManager.get(), false);
Image *imagePtr;
auto result = Image::create(productFamily, device, &desc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
std::unique_ptr<L0::Image> image(imagePtr);
ASSERT_NE(image, nullptr);
}
HWTEST2_F(ImageCreate, givenFDWhenCreatingImageWith3Channel8bitUintThenSuccessIsReturned, MatchAny) {
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
desc.type = ZE_IMAGE_TYPE_3D;
desc.format.layout = ZE_IMAGE_FORMAT_LAYOUT_8_8_8;
desc.format.type = ZE_IMAGE_FORMAT_TYPE_UINT;
desc.width = 11;
desc.height = 13;
desc.depth = 17;
desc.format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
desc.format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
desc.format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
desc.format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
ze_external_memory_import_fd_t importFd = {};
importFd.fd = 1;
importFd.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF;
importFd.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_FD;
desc.pNext = &importFd;
Image *imagePtr;
auto result = Image::create(productFamily, device, &desc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
std::unique_ptr<L0::Image> image(imagePtr);
ASSERT_NE(image, nullptr);
}
HWTEST2_F(ImageCreate, givenFDWhenCreatingImageWith3Channel16bitUintThenSuccessIsReturned, MatchAny) {
ze_image_desc_t desc = {};
desc.stype = ZE_STRUCTURE_TYPE_IMAGE_DESC;
desc.type = ZE_IMAGE_TYPE_3D;
desc.format.layout = ZE_IMAGE_FORMAT_LAYOUT_16_16_16;
desc.format.type = ZE_IMAGE_FORMAT_TYPE_UINT;
desc.width = 11;
desc.height = 13;
desc.depth = 17;
desc.format.x = ZE_IMAGE_FORMAT_SWIZZLE_R;
desc.format.y = ZE_IMAGE_FORMAT_SWIZZLE_G;
desc.format.z = ZE_IMAGE_FORMAT_SWIZZLE_B;
desc.format.w = ZE_IMAGE_FORMAT_SWIZZLE_1;
ze_external_memory_import_fd_t importFd = {};
importFd.fd = 1;
importFd.flags = ZE_EXTERNAL_MEMORY_TYPE_FLAG_DMA_BUF;
importFd.stype = ZE_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMPORT_FD;
desc.pNext = &importFd;
Image *imagePtr;
auto result = Image::create(productFamily, device, &desc, &imagePtr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
std::unique_ptr<L0::Image> image(imagePtr);
ASSERT_NE(image, nullptr);
}
} // namespace ult
} // namespace L0