From ac45ff74ec53fc84e98619b19c0a9ef7372c0741 Mon Sep 17 00:00:00 2001 From: Mateusz Jablonski Date: Thu, 5 Apr 2018 15:05:33 +0200 Subject: [PATCH] Fix creating image from image - allow creating image 2d from non NV12 image 2d - validate image descriptor and format when create image from image Change-Id: Ie7887e75f1450fc723dc1d1ae9ff5639d88835fc --- runtime/mem_obj/image.cpp | 104 ++++++--- runtime/mem_obj/image.h | 3 + unit_tests/api/cl_create_image_tests.cpp | 200 +++++++++++++++++- .../mem_obj/image2d_from_buffer_tests.cpp | 6 +- unit_tests/mem_obj/image_validate_tests.cpp | 125 ++++++++++- 5 files changed, 404 insertions(+), 34 deletions(-) diff --git a/runtime/mem_obj/image.cpp b/runtime/mem_obj/image.cpp index 0b37932ceb..fccf7037b6 100644 --- a/runtime/mem_obj/image.cpp +++ b/runtime/mem_obj/image.cpp @@ -171,17 +171,17 @@ Image *Image::create(Context *context, } if (parentImage) { - DEBUG_BREAK_IF(!IsNV12Image(&parentImage->getImageFormat())); imageWidth = parentImage->getImageDesc().image_width; imageHeight = parentImage->getImageDesc().image_height; imageDepth = 1; - - if (imageDesc->image_depth == 1) { // UV Plane - imageWidth /= 2; - imageHeight /= 2; - imgInfo.plane = GMM_PLANE_U; - } else { - imgInfo.plane = GMM_PLANE_Y; + if (IsNV12Image(&parentImage->getImageFormat())) { + if (imageDesc->image_depth == 1) { // UV Plane + imageWidth /= 2; + imageHeight /= 2; + imgInfo.plane = GMM_PLANE_U; + } else { + imgInfo.plane = GMM_PLANE_Y; + } } imgInfo.surfaceFormat = &parentImage->surfaceFormatInfo; @@ -215,10 +215,7 @@ Image *Image::create(Context *context, memory = memoryManager->createGraphicsAllocationWithPadding(memory, gmmAllocationSize); } } - } - // NV12 image planes - else if (parentImage != nullptr) { - DEBUG_BREAK_IF(!IsNV12Image(&parentImage->getImageFormat())); + } else if (parentImage != nullptr) { memory = parentImage->getGraphicsAllocation(); memory->gmm->queryImageParams(imgInfo, hwInfo); isTilingAllowed = parentImage->allowTiling(); @@ -430,6 +427,9 @@ cl_int Image::validate(Context *context, if (!surfaceFormat) { return CL_IMAGE_FORMAT_NOT_SUPPORTED; } + + Image *parentImage = castToObject(imageDesc->mem_object); + Buffer *parentBuffer = castToObject(imageDesc->mem_object); switch (imageDesc->image_type) { case CL_MEM_OBJECT_IMAGE2D: @@ -439,20 +439,21 @@ cl_int Image::validate(Context *context, imageDesc->image_height > *maxHeight) { retVal = CL_INVALID_IMAGE_SIZE; } - if (imageDesc->mem_object != nullptr) { - // Image2d from buffer - Buffer *inputBuffer = castToObject(imageDesc->mem_object); - if (inputBuffer != nullptr) { - pDevice->getCap(reinterpret_cast(pitchAlignment), srcSize, retSize); - pDevice->getCap(reinterpret_cast(baseAddressAlignment), srcSize, retSize); + if (parentBuffer) { // Image 2d from buffer + pDevice->getCap(reinterpret_cast(pitchAlignment), srcSize, retSize); + pDevice->getCap(reinterpret_cast(baseAddressAlignment), srcSize, retSize); - if ((imageDesc->image_row_pitch % (*pitchAlignment)) || - ((inputBuffer->getFlags() & CL_MEM_USE_HOST_PTR) && (reinterpret_cast(inputBuffer->getHostPtr()) % (*baseAddressAlignment))) || - (imageDesc->image_height * (imageDesc->image_row_pitch != 0 ? imageDesc->image_row_pitch : imageDesc->image_width) > inputBuffer->getSize())) { - retVal = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR; - } else if (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)) { - retVal = CL_INVALID_VALUE; - } + if ((imageDesc->image_row_pitch % (*pitchAlignment)) || + ((parentBuffer->getFlags() & CL_MEM_USE_HOST_PTR) && (reinterpret_cast(parentBuffer->getHostPtr()) % (*baseAddressAlignment))) || + (imageDesc->image_height * (imageDesc->image_row_pitch != 0 ? imageDesc->image_row_pitch : imageDesc->image_width) > parentBuffer->getSize())) { + retVal = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR; + } else if (flags & (CL_MEM_USE_HOST_PTR | CL_MEM_COPY_HOST_PTR)) { + retVal = CL_INVALID_VALUE; + } + } + if (parentImage && !IsNV12Image(&parentImage->getImageFormat())) { // Image 2d from image 2d + if (!parentImage->hasSameDescriptor(*imageDesc) || !parentImage->hasValidParentImageFormat(surfaceFormat->OCLImageFormat)) { + retVal = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR; } } else if (imageDesc->image_width == 0 || imageDesc->image_height == 0) { @@ -460,6 +461,9 @@ cl_int Image::validate(Context *context, } break; default: + if (parentImage) { + retVal = CL_INVALID_IMAGE_DESCRIPTOR; + } break; } if (hostPtr == nullptr) { @@ -475,8 +479,12 @@ cl_int Image::validate(Context *context, } } - if ((imageDesc->mem_object != nullptr) && (imageDesc->image_type != CL_MEM_OBJECT_IMAGE1D_BUFFER) && (imageDesc->image_type != CL_MEM_OBJECT_IMAGE2D)) { - retVal = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR; + if (parentBuffer && imageDesc->image_type != CL_MEM_OBJECT_IMAGE1D_BUFFER && imageDesc->image_type != CL_MEM_OBJECT_IMAGE2D) { + retVal = CL_INVALID_IMAGE_DESCRIPTOR; + } + + if (parentImage && imageDesc->image_type != CL_MEM_OBJECT_IMAGE2D) { + retVal = CL_INVALID_IMAGE_DESCRIPTOR; } if (retVal != CL_SUCCESS) { @@ -1256,4 +1264,44 @@ bool Image::validateRegionAndOrigin(const size_t *origin, const size_t *region, uint32_t mipLevel = findMipLevel(imgDesc.image_type, origin); return mipLevel < imgDesc.num_mip_levels; } -} // namespace OCLRT + +bool Image::hasSameDescriptor(const cl_image_desc &imageDesc) const { + return this->imageDesc.image_type == imageDesc.image_type && + this->imageDesc.image_width == imageDesc.image_width && + this->imageDesc.image_height == imageDesc.image_height && + this->imageDesc.image_depth == imageDesc.image_depth && + this->imageDesc.image_array_size == imageDesc.image_array_size && + this->hostPtrRowPitch == imageDesc.image_row_pitch && + this->hostPtrSlicePitch == imageDesc.image_slice_pitch && + this->imageDesc.num_mip_levels == imageDesc.num_mip_levels && + this->imageDesc.num_samples == imageDesc.num_samples; +} + +bool Image::hasValidParentImageFormat(const cl_image_format &imageFormat) const { + if (this->imageFormat.image_channel_data_type != imageFormat.image_channel_data_type) { + return false; + } + switch (this->imageFormat.image_channel_order) { + case CL_BGRA: + return imageFormat.image_channel_order == CL_sBGRA; + case CL_sBGRA: + return imageFormat.image_channel_order == CL_BGRA; + case CL_RGBA: + return imageFormat.image_channel_order == CL_sRGBA; + case CL_sRGBA: + return imageFormat.image_channel_order == CL_RGBA; + case CL_RGB: + return imageFormat.image_channel_order == CL_sRGB; + case CL_sRGB: + return imageFormat.image_channel_order == CL_RGB; + case CL_RGBx: + return imageFormat.image_channel_order == CL_sRGBx; + case CL_sRGBx: + return imageFormat.image_channel_order == CL_RGBx; + case CL_R: + return imageFormat.image_channel_order == CL_DEPTH; + default: + return false; + } +} +} diff --git a/runtime/mem_obj/image.h b/runtime/mem_obj/image.h index 2d54c7ad52..e40fc7b531 100644 --- a/runtime/mem_obj/image.h +++ b/runtime/mem_obj/image.h @@ -187,6 +187,9 @@ class Image : public MemObj { const bool isTiledImage; + bool hasSameDescriptor(const cl_image_desc &imageDesc) const; + bool hasValidParentImageFormat(const cl_image_format &imageFormat) const; + protected: Image(Context *context, cl_mem_flags flags, diff --git a/unit_tests/api/cl_create_image_tests.cpp b/unit_tests/api/cl_create_image_tests.cpp index 61ed721c60..c10e6573e0 100644 --- a/unit_tests/api/cl_create_image_tests.cpp +++ b/unit_tests/api/cl_create_image_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Intel Corporation + * Copyright (c) 2017 - 2018, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -675,4 +675,200 @@ TEST_F(clCreateImage3DTest, GivenInvalidContextsWhenImageIsCreatedThenReturnsFai EXPECT_EQ(CL_INVALID_CONTEXT, retVal); EXPECT_EQ(nullptr, image); } -} // namespace ULT + +typedef clCreateImageTests<::testing::Test> clCreateImageFromImageTest; + +TEST_F(clCreateImageFromImageTest, givenImage2dWhenCreateImage2dFromImageWithTheSameDescriptorAndValidFormatThenReturnsSuccess) { + + imageFormat.image_channel_order = CL_BGRA; + + auto image = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(nullptr, image); + + retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_width), &imageDesc.image_width, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_height), &imageDesc.image_height, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, sizeof(imageDesc.image_depth), &imageDesc.image_depth, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, sizeof(imageDesc.image_row_pitch), &imageDesc.image_row_pitch, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, sizeof(imageDesc.image_slice_pitch), &imageDesc.image_slice_pitch, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, sizeof(imageDesc.num_mip_levels), &imageDesc.num_mip_levels, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, sizeof(imageDesc.num_samples), &imageDesc.num_samples, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, sizeof(imageDesc.image_array_size), &imageDesc.image_array_size, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + + imageDesc.mem_object = image; + imageFormat.image_channel_order = CL_sBGRA; + + auto imageFromImageObject = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + + EXPECT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(nullptr, imageFromImageObject); + + retVal = clReleaseMemObject(image); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clReleaseMemObject(imageFromImageObject); + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST_F(clCreateImageFromImageTest, givenImage2dWhenCreateImage2dFromImageWithDifferentDescriptorAndValidFormatThenReturnsError) { + + imageFormat.image_channel_order = CL_BGRA; + + auto image = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(nullptr, image); + + retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_width), &imageDesc.image_width, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_height), &imageDesc.image_height, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, sizeof(imageDesc.image_depth), &imageDesc.image_depth, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, sizeof(imageDesc.image_row_pitch), &imageDesc.image_row_pitch, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, sizeof(imageDesc.image_slice_pitch), &imageDesc.image_slice_pitch, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, sizeof(imageDesc.num_mip_levels), &imageDesc.num_mip_levels, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, sizeof(imageDesc.num_samples), &imageDesc.num_samples, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, sizeof(imageDesc.image_array_size), &imageDesc.image_array_size, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + imageDesc.mem_object = image; + imageDesc.image_width++; + imageFormat.image_channel_order = CL_sBGRA; + + auto imageFromImageObject = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + + EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retVal); + EXPECT_EQ(nullptr, imageFromImageObject); + + retVal = clReleaseMemObject(image); + EXPECT_EQ(CL_SUCCESS, retVal); +} + +TEST_F(clCreateImageFromImageTest, givenImage2dWhenCreateImage2dFromImageWithTheSameDescriptorAndNotValidFormatThenReturnsError) { + + imageFormat.image_channel_order = CL_BGRA; + + auto image = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + + ASSERT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(nullptr, image); + + retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_width), &imageDesc.image_width, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_height), &imageDesc.image_height, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, sizeof(imageDesc.image_depth), &imageDesc.image_depth, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, sizeof(imageDesc.image_row_pitch), &imageDesc.image_row_pitch, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, sizeof(imageDesc.image_slice_pitch), &imageDesc.image_slice_pitch, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, sizeof(imageDesc.num_mip_levels), &imageDesc.num_mip_levels, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, sizeof(imageDesc.num_samples), &imageDesc.num_samples, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, sizeof(imageDesc.image_array_size), &imageDesc.image_array_size, nullptr); + EXPECT_EQ(CL_SUCCESS, retVal); + imageDesc.mem_object = image; + imageFormat.image_channel_order = CL_BGRA; + + auto imageFromImageObject = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + + EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retVal); + EXPECT_EQ(nullptr, imageFromImageObject); + + retVal = clReleaseMemObject(image); + EXPECT_EQ(CL_SUCCESS, retVal); +} + +uint32_t non2dImageTypes[] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE1D_BUFFER, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D}; + +struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest, + public ::testing::WithParamInterface { + void SetUp() override { + clCreateImageFromImageTest::SetUp(); + image = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + EXPECT_EQ(CL_SUCCESS, retVal); + EXPECT_NE(nullptr, image); + imageDesc.mem_object = image; + } + void TearDown() override { + retVal = clReleaseMemObject(image); + clCreateImageFromImageTest::TearDown(); + } + cl_mem image; +}; + +TEST_P(clCreateNon2dImageFromImageTest, givenImage2dWhenCreateImageFromNon2dImageThenReturnsError) { + + imageDesc.image_type = GetParam(); + auto imageFromImageObject = clCreateImage( + pContext, + CL_MEM_READ_ONLY, + &imageFormat, + &imageDesc, + nullptr, + &retVal); + + EXPECT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal); + EXPECT_EQ(nullptr, imageFromImageObject); +} + +INSTANTIATE_TEST_CASE_P(clCreateNon2dImageFromImageTests, + clCreateNon2dImageFromImageTest, + ::testing::ValuesIn(non2dImageTypes)); +} diff --git a/unit_tests/mem_obj/image2d_from_buffer_tests.cpp b/unit_tests/mem_obj/image2d_from_buffer_tests.cpp index 44225ba4ea..00ded62a9e 100644 --- a/unit_tests/mem_obj/image2d_from_buffer_tests.cpp +++ b/unit_tests/mem_obj/image2d_from_buffer_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Intel Corporation + * Copyright (c) 2017 - 2018, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -91,12 +91,12 @@ TEST_F(Image2dFromBufferTest, CreateImage2dFromBuffer) { EXPECT_EQ(1, buffer->getRefInternalCount()); } -TEST_F(Image2dFromBufferTest, InvalidImageType) { +TEST_F(Image2dFromBufferTest, givenBufferWhenCreateImage2dArrayFromBufferThenImageDescriptorIsInvalid) { imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY; cl_mem_flags flags = CL_MEM_READ_ONLY; auto surfaceFormat = (SurfaceFormatInfo *)Image::getSurfaceFormatFromTable(flags, &imageFormat); retVal = Image::validate(&context, flags, surfaceFormat, &imageDesc, NULL); - EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retVal); + EXPECT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal); } TEST_F(Image2dFromBufferTest, CalculateRowPitch) { auto imageFromBuffer = createImage(); diff --git a/unit_tests/mem_obj/image_validate_tests.cpp b/unit_tests/mem_obj/image_validate_tests.cpp index b29f22ad47..6b8a2f8506 100644 --- a/unit_tests/mem_obj/image_validate_tests.cpp +++ b/unit_tests/mem_obj/image_validate_tests.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Intel Corporation + * Copyright (c) 2017 - 2018, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -20,11 +20,13 @@ * OTHER DEALINGS IN THE SOFTWARE. */ +#include "runtime/helpers/array_count.h" #include "runtime/helpers/surface_formats.h" #include "runtime/helpers/aligned_memory.h" #include "runtime/mem_obj/image.h" #include "runtime/helpers/convert_color.h" #include "unit_tests/mocks/mock_context.h" +#include "unit_tests/mocks/mock_graphics_allocation.h" #include "gtest/gtest.h" using namespace OCLRT; @@ -769,3 +771,124 @@ INSTANTIATE_TEST_CASE_P( NormalizingFactorTests, NormalizingFactorTests, ::testing::ValuesIn(normalizingFactorValues)); + +using ValidParentImageFormatTest = ::testing::TestWithParam>; + +cl_channel_order allChannelOrders[] = {CL_R, CL_A, CL_RG, CL_RA, CL_RGB, CL_RGBA, CL_BGRA, CL_ARGB, CL_INTENSITY, CL_LUMINANCE, CL_Rx, CL_RGx, CL_RGBx, CL_DEPTH, CL_DEPTH_STENCIL, CL_sRGB, + CL_sRGBx, CL_sRGBA, CL_sBGRA, CL_ABGR, CL_NV12_INTEL}; + +struct NullImage : public Image { + using Image::imageDesc; + using Image::imageFormat; + + NullImage() : Image(nullptr, cl_mem_flags{}, 0, nullptr, cl_image_format{}, + cl_image_desc{}, false, new MockGraphicsAllocation(nullptr, 0), false, false, + 0, 0, SurfaceFormatInfo{}, nullptr) { + } + ~NullImage() override { + delete this->graphicsAllocation; + } + void setImageArg(void *memory, bool isMediaBlockImage, uint32_t mipLevel) override {} + void setMediaImageArg(void *memory) override {} + void setMediaSurfaceRotation(void *memory) override {} + void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) override {} + void transformImage2dArrayTo3d(void *memory) override {} + void transformImage3dTo2dArray(void *memory) override {} +}; + +TEST_P(ValidParentImageFormatTest, givenParentChannelOrderWhenTestWithAllChannelOrdersThenReturnTrueForValidChannelOrder) { + cl_image_format parentImageFormat; + cl_image_format imageFormat; + cl_channel_order validChannelOrder; + NullImage image; + std::tie(parentImageFormat.image_channel_order, validChannelOrder) = GetParam(); + parentImageFormat.image_channel_data_type = CL_UNORM_INT8; + imageFormat.image_channel_data_type = CL_UNORM_INT8; + image.imageFormat = parentImageFormat; + + bool retVal; + for (unsigned int i = 0; i < ARRAY_COUNT(allChannelOrders); i++) { + imageFormat.image_channel_order = allChannelOrders[i]; + retVal = image.hasValidParentImageFormat(imageFormat); + EXPECT_EQ(imageFormat.image_channel_order == validChannelOrder, retVal); + } +}; +std::tuple imageFromImageValidChannelOrderPairs[] = { + std::make_tuple(CL_BGRA, CL_sBGRA), + std::make_tuple(CL_sBGRA, CL_BGRA), + std::make_tuple(CL_RGBA, CL_sRGBA), + std::make_tuple(CL_sRGBA, CL_RGBA), + std::make_tuple(CL_RGB, CL_sRGB), + std::make_tuple(CL_sRGB, CL_RGB), + std::make_tuple(CL_RGBx, CL_sRGBx), + std::make_tuple(CL_sRGBx, CL_RGBx), + std::make_tuple(CL_R, CL_DEPTH), + std::make_tuple(CL_A, 0), + std::make_tuple(CL_RG, 0), + std::make_tuple(CL_RA, 0), + std::make_tuple(CL_ARGB, 0), + std::make_tuple(CL_INTENSITY, 0), + std::make_tuple(CL_LUMINANCE, 0), + std::make_tuple(CL_Rx, 0), + std::make_tuple(CL_RGx, 0), + std::make_tuple(CL_DEPTH, 0), + std::make_tuple(CL_DEPTH_STENCIL, 0), + std::make_tuple(CL_ABGR, 0), + std::make_tuple(CL_NV12_INTEL, 0)}; + +INSTANTIATE_TEST_CASE_P( + ValidParentImageFormatTests, + ValidParentImageFormatTest, + ::testing::ValuesIn(imageFromImageValidChannelOrderPairs)); + +TEST(ImageDescriptorComparatorTest, givenImageWhenCallHasSameDescriptorWithSameDescriptorThenReturnTrueOtherwiseFalse) { + NullImage image; + cl_image_desc descriptor = image.imageDesc; + image.imageDesc.image_row_pitch = image.getHostPtrRowPitch() + 10; // to make sure we compare host ptr row/slice pitches + image.imageDesc.image_slice_pitch = image.getHostPtrSlicePitch() + 10; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.image_type++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.image_type--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.image_width++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.image_width--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.image_height++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.image_height--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.image_depth++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.image_depth--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.image_array_size++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.image_array_size--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.image_row_pitch++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.image_row_pitch--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.image_slice_pitch++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.image_slice_pitch--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.num_mip_levels++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); + descriptor.num_mip_levels--; + EXPECT_TRUE(image.hasSameDescriptor(descriptor)); + descriptor.num_samples++; + EXPECT_FALSE(image.hasSameDescriptor(descriptor)); +}; + +TEST(ImageFormatValidatorTest, givenValidParentChannelOrderAndChannelOrderWhenFormatsHaveDifferentDataTypeThenHasValidParentImageFormatReturnsFalse) { + cl_image_format imageFormat; + NullImage image; + image.imageFormat.image_channel_data_type = CL_UNORM_INT8; + image.imageFormat.image_channel_order = CL_BGRA; + imageFormat.image_channel_data_type = CL_UNORM_INT16; + imageFormat.image_channel_order = CL_sBGRA; + EXPECT_FALSE(image.hasValidParentImageFormat(imageFormat)); +};