| // |
| // Copyright (c) 2017 The Khronos Group Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| #include "testBase.h" |
| #if defined(__APPLE__) |
| #include <OpenGL/glu.h> |
| #else |
| #include <GL/glu.h> |
| #endif |
| |
| const char *get_kernel_suffix(cl_image_format *format) |
| { |
| switch (format->image_channel_data_type) |
| { |
| case CL_UNORM_INT8: |
| case CL_UNORM_INT16: |
| case CL_UNORM_INT24: |
| case CL_SNORM_INT8: |
| case CL_SNORM_INT16: |
| case CL_HALF_FLOAT: |
| case CL_FLOAT: |
| case CL_UNORM_INT_101010: return "f"; |
| case CL_SIGNED_INT8: |
| case CL_SIGNED_INT16: |
| case CL_SIGNED_INT32: return "i"; |
| case CL_UNSIGNED_INT8: |
| case CL_UNSIGNED_INT16: |
| case CL_UNSIGNED_INT32: return "ui"; |
| default: |
| log_error("Test error: unsupported kernel suffix for " |
| "image_channel_data_type 0x%X\n", |
| format->image_channel_data_type); |
| return ""; |
| } |
| } |
| |
| ExplicitType get_read_kernel_type(cl_image_format *format) |
| { |
| switch (format->image_channel_data_type) |
| { |
| case CL_UNORM_INT8: |
| case CL_UNORM_INT16: |
| case CL_UNORM_INT24: |
| case CL_SNORM_INT8: |
| case CL_SNORM_INT16: |
| case CL_HALF_FLOAT: |
| case CL_FLOAT: |
| case CL_UNORM_INT_101010: |
| #ifdef GL_VERSION_3_2 |
| case CL_DEPTH: |
| #endif |
| return kFloat; |
| case CL_SIGNED_INT8: |
| case CL_SIGNED_INT16: |
| case CL_SIGNED_INT32: return kInt; |
| case CL_UNSIGNED_INT8: |
| case CL_UNSIGNED_INT16: |
| case CL_UNSIGNED_INT32: return kUInt; |
| default: |
| log_error("Test error: unsupported kernel suffix for " |
| "image_channel_data_type 0x%X\n", |
| format->image_channel_data_type); |
| return kNumExplicitTypes; |
| } |
| } |
| |
| ExplicitType get_write_kernel_type(cl_image_format *format) |
| { |
| switch (format->image_channel_data_type) |
| { |
| case CL_UNORM_INT8: return kFloat; |
| case CL_UNORM_INT16: return kFloat; |
| case CL_UNORM_INT24: return kFloat; |
| case CL_SNORM_INT8: return kFloat; |
| case CL_SNORM_INT16: return kFloat; |
| case CL_HALF_FLOAT: return kHalf; |
| case CL_FLOAT: return kFloat; |
| case CL_SIGNED_INT8: return kChar; |
| case CL_SIGNED_INT16: return kShort; |
| case CL_SIGNED_INT32: return kInt; |
| case CL_UNSIGNED_INT8: return kUChar; |
| case CL_UNSIGNED_INT16: return kUShort; |
| case CL_UNSIGNED_INT32: return kUInt; |
| case CL_UNORM_INT_101010: return kFloat; |
| #ifdef GL_VERSION_3_2 |
| case CL_DEPTH: return kFloat; |
| #endif |
| default: return kInt; |
| } |
| } |
| |
| const char *get_write_conversion(cl_image_format *format, ExplicitType type) |
| { |
| switch (format->image_channel_data_type) |
| { |
| case CL_UNORM_INT8: |
| case CL_UNORM_INT16: |
| case CL_SNORM_INT8: |
| case CL_SNORM_INT16: |
| case CL_HALF_FLOAT: |
| case CL_FLOAT: |
| case CL_UNORM_INT_101010: |
| case CL_UNORM_INT24: |
| if (type != kFloat) return "convert_float4"; |
| break; |
| case CL_SIGNED_INT8: |
| case CL_SIGNED_INT16: |
| case CL_SIGNED_INT32: |
| if (type != kInt) return "convert_int4"; |
| break; |
| case CL_UNSIGNED_INT8: |
| case CL_UNSIGNED_INT16: |
| case CL_UNSIGNED_INT32: |
| if (type != kUInt) return "convert_uint4"; |
| break; |
| default: return ""; |
| } |
| return ""; |
| } |
| |
| // The only three input types to this function are kInt, kUInt and kFloat, due |
| // to the way we set up our tests The output types, though, are pretty much |
| // anything valid for GL to receive |
| |
| #define DOWNSCALE_INTEGER_CASE(enum, type, bitShift) \ |
| case enum: { \ |
| cl_##type *dst = new cl_##type[numPixels * 4]; \ |
| for (size_t i = 0; i < numPixels * 4; i++) dst[i] = src[i]; \ |
| return (char *)dst; \ |
| } |
| |
| #define UPSCALE_FLOAT_CASE(enum, type, typeMax) \ |
| case enum: { \ |
| cl_##type *dst = new cl_##type[numPixels * 4]; \ |
| for (size_t i = 0; i < numPixels * 4; i++) \ |
| dst[i] = (cl_##type)(src[i] * typeMax); \ |
| return (char *)dst; \ |
| } |
| |
| char *convert_to_expected(void *inputBuffer, size_t numPixels, |
| ExplicitType inType, ExplicitType outType, |
| size_t channelNum, GLenum glDataType) |
| { |
| #ifdef DEBUG |
| log_info("- Converting from input type '%s' to output type '%s'\n", |
| get_explicit_type_name(inType), get_explicit_type_name(outType)); |
| #endif |
| |
| if (inType == outType) |
| { |
| char *outData = |
| new char[numPixels * channelNum |
| * get_explicit_type_size(outType)]; // sizeof( cl_int ) ]; |
| if (glDataType == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) |
| { |
| for (size_t i = 0; i < numPixels; ++i) |
| { |
| ((cl_float *)outData)[i] = ((cl_float *)inputBuffer)[2 * i]; |
| } |
| } |
| else |
| { |
| memcpy(outData, inputBuffer, |
| numPixels * channelNum * get_explicit_type_size(inType)); |
| } |
| return outData; |
| } |
| else if (inType == kChar) |
| { |
| cl_char *src = (cl_char *)inputBuffer; |
| |
| switch (outType) |
| { |
| case kInt: { |
| cl_int *outData = new cl_int[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_int)((src[i])); |
| } |
| return (char *)outData; |
| } |
| case kFloat: { |
| // If we're converting to float, then CL decided that we should |
| // be normalized |
| cl_float *outData = new cl_float[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_float)src[i] / 127.0f; |
| } |
| return (char *)outData; |
| } |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| else if (inType == kUChar) |
| { |
| cl_uchar *src = (cl_uchar *)inputBuffer; |
| |
| switch (outType) |
| { |
| case kUInt: { |
| cl_uint *outData = new cl_uint[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_uint)((src[i])); |
| } |
| return (char *)outData; |
| } |
| case kFloat: { |
| // If we're converting to float, then CL decided that we should |
| // be normalized |
| cl_float *outData = new cl_float[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_float)(src[i]) / 256.0f; |
| } |
| return (char *)outData; |
| } |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| else if (inType == kShort) |
| { |
| cl_short *src = (cl_short *)inputBuffer; |
| |
| switch (outType) |
| { |
| case kInt: { |
| cl_int *outData = new cl_int[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_int)((src[i])); |
| } |
| return (char *)outData; |
| } |
| case kFloat: { |
| // If we're converting to float, then CL decided that we should |
| // be normalized |
| cl_float *outData = new cl_float[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_float)src[i] / 32768.0f; |
| } |
| return (char *)outData; |
| } |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| else if (inType == kUShort) |
| { |
| cl_ushort *src = (cl_ushort *)inputBuffer; |
| |
| switch (outType) |
| { |
| case kUInt: { |
| cl_uint *outData = new cl_uint[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_uint)((src[i])); |
| } |
| return (char *)outData; |
| } |
| case kFloat: { |
| // If we're converting to float, then CL decided that we should |
| // be normalized |
| cl_float *outData = new cl_float[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_float)(src[i]) / 65535.0f; |
| } |
| return (char *)outData; |
| } |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| else if (inType == kInt) |
| { |
| cl_int *src = (cl_int *)inputBuffer; |
| |
| switch (outType) |
| { |
| DOWNSCALE_INTEGER_CASE(kShort, short, 16) |
| DOWNSCALE_INTEGER_CASE(kChar, char, 24) |
| case kFloat: { |
| // If we're converting to float, then CL decided that we should |
| // be normalized |
| cl_float *outData = new cl_float[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = |
| (cl_float)fmaxf((float)src[i] / 2147483647.f, -1.f); |
| } |
| return (char *)outData; |
| } |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| else if (inType == kUInt) |
| { |
| cl_uint *src = (cl_uint *)inputBuffer; |
| |
| switch (outType) |
| { |
| DOWNSCALE_INTEGER_CASE(kUShort, ushort, 16) |
| DOWNSCALE_INTEGER_CASE(kUChar, uchar, 24) |
| case kFloat: { |
| // If we're converting to float, then CL decided that we should |
| // be normalized |
| cl_float *outData = new cl_float[numPixels * channelNum]; |
| const cl_float MaxValue = (glDataType == GL_UNSIGNED_INT_24_8) |
| ? 16777215.f |
| : 4294967295.f; |
| const cl_uint ShiftBits = |
| (glDataType == GL_UNSIGNED_INT_24_8) ? 8 : 0; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = (cl_float)(src[i] >> ShiftBits) / MaxValue; |
| } |
| return (char *)outData; |
| } |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| else if (inType == kHalf) |
| { |
| cl_half *src = (cl_half *)inputBuffer; |
| |
| switch (outType) |
| { |
| case kFloat: { |
| cl_float *outData = new cl_float[numPixels * channelNum]; |
| for (size_t i = 0; i < numPixels * channelNum; i++) |
| { |
| outData[i] = cl_half_to_float(src[i]); |
| } |
| return (char *)outData; |
| } |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| else |
| { |
| cl_float *src = (cl_float *)inputBuffer; |
| |
| switch (outType) |
| { |
| UPSCALE_FLOAT_CASE(kChar, char, 127.f) |
| UPSCALE_FLOAT_CASE(kUChar, uchar, 255.f) |
| UPSCALE_FLOAT_CASE(kShort, short, 32767.f) |
| UPSCALE_FLOAT_CASE(kUShort, ushort, 65535.f) |
| UPSCALE_FLOAT_CASE(kInt, int, 2147483647.f) |
| UPSCALE_FLOAT_CASE(kUInt, uint, 4294967295.f) |
| default: |
| log_error("ERROR: Unsupported conversion from %s to %s!\n", |
| get_explicit_type_name(inType), |
| get_explicit_type_name(outType)); |
| return NULL; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| int validate_integer_results(void *expectedResults, void *actualResults, |
| size_t width, size_t height, size_t sampleNum, |
| size_t typeSize) |
| { |
| return validate_integer_results(expectedResults, actualResults, width, |
| height, sampleNum, 0, typeSize); |
| } |
| |
| int validate_integer_results(void *expectedResults, void *actualResults, |
| size_t width, size_t height, size_t depth, |
| size_t sampleNum, size_t typeSize) |
| { |
| char *expected = (char *)expectedResults; |
| char *actual = (char *)actualResults; |
| for (size_t s = 0; s < sampleNum; s++) |
| { |
| for (size_t z = 0; z < ((depth == 0) ? 1 : depth); z++) |
| { |
| for (size_t y = 0; y < height; y++) |
| { |
| for (size_t x = 0; x < width; x++) |
| { |
| if (memcmp(expected, actual, typeSize * 4) != 0) |
| { |
| char scratch[1024]; |
| |
| if (depth == 0) |
| log_error("ERROR: Data sample %d,%d,%d did not " |
| "validate!\n", |
| (int)x, (int)y, (int)s); |
| else |
| log_error("ERROR: Data sample %d,%d,%d,%d did not " |
| "validate!\n", |
| (int)x, (int)y, (int)z, (int)s); |
| log_error("\tExpected: %s\n", |
| GetDataVectorString(expected, typeSize, 4, |
| scratch)); |
| log_error( |
| "\t Actual: %s\n", |
| GetDataVectorString(actual, typeSize, 4, scratch)); |
| return -1; |
| } |
| expected += typeSize * 4; |
| actual += typeSize * 4; |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| int validate_float_results(void *expectedResults, void *actualResults, |
| size_t width, size_t height, size_t sampleNum, |
| size_t channelNum) |
| { |
| return validate_float_results(expectedResults, actualResults, width, height, |
| sampleNum, 0, channelNum); |
| } |
| |
| int validate_float_results(void *expectedResults, void *actualResults, |
| size_t width, size_t height, size_t depth, |
| size_t sampleNum, size_t channelNum) |
| { |
| cl_float *expected = (cl_float *)expectedResults; |
| cl_float *actual = (cl_float *)actualResults; |
| for (size_t s = 0; s < sampleNum; s++) |
| { |
| for (size_t z = 0; z < ((depth == 0) ? 1 : depth); z++) |
| { |
| for (size_t y = 0; y < height; y++) |
| { |
| for (size_t x = 0; x < width; x++) |
| { |
| float err = 0.f; |
| for (size_t i = 0; i < channelNum; i++) |
| { |
| float error = fabsf(expected[i] - actual[i]); |
| if (error > err) err = error; |
| } |
| |
| if (err > 1.f / 127.f) // Max expected range of error if we |
| // converted from an 8-bit integer to |
| // a normalized float |
| { |
| if (depth == 0) |
| log_error("ERROR: Data sample %d,%d,%d did not " |
| "validate!\n", |
| (int)x, (int)y, (int)s); |
| else |
| log_error("ERROR: Data sample %d,%d,%d,%d did not " |
| "validate!\n", |
| (int)x, (int)y, (int)z, (int)s); |
| |
| if (channelNum == 4) |
| { |
| log_error("\tExpected: %f %f %f %f\n", expected[0], |
| expected[1], expected[2], expected[3]); |
| log_error("\t : %a %a %a %a\n", expected[0], |
| expected[1], expected[2], expected[3]); |
| log_error("\t Actual: %f %f %f %f\n", actual[0], |
| actual[1], actual[2], actual[3]); |
| log_error("\t : %a %a %a %a\n", actual[0], |
| actual[1], actual[2], actual[3]); |
| } |
| else if (channelNum == 1) |
| { |
| log_error("\tExpected: %f\n", expected[0]); |
| log_error("\t : %a\n", expected[0]); |
| log_error("\t Actual: %f\n", actual[0]); |
| log_error("\t : %a\n", actual[0]); |
| } |
| return -1; |
| } |
| expected += channelNum; |
| actual += channelNum; |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| int validate_float_results_rgb_101010(void *expectedResults, |
| void *actualResults, size_t width, |
| size_t height, size_t sampleNum) |
| { |
| return validate_float_results_rgb_101010(expectedResults, actualResults, |
| width, height, sampleNum, 0); |
| } |
| |
| int validate_float_results_rgb_101010(void *expectedResults, |
| void *actualResults, size_t width, |
| size_t height, size_t depth, |
| size_t sampleNum) |
| { |
| cl_float *expected = (cl_float *)expectedResults; |
| cl_float *actual = (cl_float *)actualResults; |
| for (size_t s = 0; s < sampleNum; s++) |
| { |
| for (size_t z = 0; z < ((depth == 0) ? 1 : depth); z++) |
| { |
| for (size_t y = 0; y < height; y++) |
| { |
| for (size_t x = 0; x < width; x++) |
| { |
| float err = 0.f; |
| for (size_t i = 0; i < 3; i++) // skip the fourth channel |
| { |
| float error = fabsf(expected[i] - actual[i]); |
| if (error > err) err = error; |
| } |
| |
| if (err > 1.f / 127.f) // Max expected range of error if we |
| // converted from an 8-bit integer to |
| // a normalized float |
| { |
| if (depth == 0) |
| log_error("ERROR: Data sample %d,%d,%d did not " |
| "validate!\n", |
| (int)x, (int)y, (int)s); |
| else |
| log_error("ERROR: Data sample %d,%d,%d,%d did not " |
| "validate!\n", |
| (int)x, (int)y, (int)z, (int)s); |
| log_error("\tExpected: %f %f %f\n", expected[0], |
| expected[1], expected[2]); |
| log_error("\t : %a %a %a\n", expected[0], |
| expected[1], expected[2]); |
| log_error("\t Actual: %f %f %f\n", actual[0], |
| actual[1], actual[2]); |
| log_error("\t : %a %a %a\n", actual[0], |
| actual[1], actual[2]); |
| return -1; |
| } |
| expected += 4; |
| actual += 4; |
| } |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| int CheckGLObjectInfo(cl_mem mem, cl_gl_object_type expected_cl_gl_type, |
| GLuint expected_gl_name, |
| GLenum expected_cl_gl_texture_target, |
| GLint expected_cl_gl_mipmap_level) |
| { |
| cl_gl_object_type object_type; |
| GLuint object_name; |
| GLenum texture_target; |
| GLint mipmap_level; |
| int error; |
| |
| error = (*clGetGLObjectInfo_ptr)(mem, &object_type, &object_name); |
| test_error(error, "clGetGLObjectInfo failed"); |
| if (object_type != expected_cl_gl_type) |
| { |
| log_error("clGetGLObjectInfo did not return expected object type: " |
| "expected %d, got %d.\n", |
| expected_cl_gl_type, object_type); |
| return -1; |
| } |
| if (object_name != expected_gl_name) |
| { |
| log_error("clGetGLObjectInfo did not return expected object name: " |
| "expected %d, got %d.\n", |
| expected_gl_name, object_name); |
| return -1; |
| } |
| |
| // If we're dealing with a buffer or render buffer, we are done. |
| |
| if (object_type == CL_GL_OBJECT_BUFFER |
| || object_type == CL_GL_OBJECT_RENDERBUFFER) |
| { |
| return 0; |
| } |
| |
| // Otherwise, it's a texture-based object and requires a bit more checking. |
| |
| error = (*clGetGLTextureInfo_ptr)(mem, CL_GL_TEXTURE_TARGET, |
| sizeof(texture_target), &texture_target, |
| NULL); |
| test_error(error, "clGetGLTextureInfo for CL_GL_TEXTURE_TARGET failed"); |
| |
| if (texture_target != expected_cl_gl_texture_target) |
| { |
| log_error("clGetGLTextureInfo did not return expected texture target: " |
| "expected %d, got %d.\n", |
| expected_cl_gl_texture_target, texture_target); |
| return -1; |
| } |
| |
| error = (*clGetGLTextureInfo_ptr)( |
| mem, CL_GL_MIPMAP_LEVEL, sizeof(mipmap_level), &mipmap_level, NULL); |
| test_error(error, "clGetGLTextureInfo for CL_GL_MIPMAP_LEVEL failed"); |
| |
| if (mipmap_level != expected_cl_gl_mipmap_level) |
| { |
| log_error("clGetGLTextureInfo did not return expected mipmap level: " |
| "expected %d, got %d.\n", |
| expected_cl_gl_mipmap_level, mipmap_level); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| bool CheckGLIntegerExtensionSupport() |
| { |
| // Get the OpenGL version and supported extensions |
| const GLubyte *glVersion = glGetString(GL_VERSION); |
| const GLubyte *glExtensionList = glGetString(GL_EXTENSIONS); |
| |
| // Check if the OpenGL vrsion is 3.0 or grater or GL_EXT_texture_integer is |
| // supported |
| return ( |
| ((glVersion[0] - '0') >= 3) |
| || (strstr((const char *)glExtensionList, "GL_EXT_texture_integer"))); |
| } |
| |
| int is_rgb_101010_supported(cl_context context, GLenum gl_target) |
| { |
| cl_image_format formatList[128]; |
| cl_uint formatCount = 0; |
| unsigned int i; |
| int error; |
| |
| cl_mem_object_type image_type; |
| |
| switch (get_base_gl_target(gl_target)) |
| { |
| case GL_TEXTURE_1D: image_type = CL_MEM_OBJECT_IMAGE1D; |
| case GL_TEXTURE_BUFFER: |
| image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER; |
| break; |
| case GL_TEXTURE_RECTANGLE_EXT: |
| case GL_TEXTURE_2D: |
| case GL_COLOR_ATTACHMENT0: |
| case GL_RENDERBUFFER: |
| case GL_TEXTURE_CUBE_MAP: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| image_type = CL_MEM_OBJECT_IMAGE2D; |
| break; |
| case GL_TEXTURE_3D: image_type = CL_MEM_OBJECT_IMAGE3D; |
| case GL_TEXTURE_1D_ARRAY: image_type = CL_MEM_OBJECT_IMAGE1D_ARRAY; |
| case GL_TEXTURE_2D_ARRAY: |
| image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY; |
| break; |
| default: image_type = CL_MEM_OBJECT_IMAGE2D; |
| } |
| |
| if ((error = |
| clGetSupportedImageFormats(context, CL_MEM_READ_WRITE, image_type, |
| 128, formatList, &formatCount))) |
| { |
| return error; |
| } |
| |
| // Check if the RGB 101010 format is supported |
| for (i = 0; i < formatCount; i++) |
| { |
| if (formatList[i].image_channel_data_type == CL_UNORM_INT_101010) |
| { |
| return 1; |
| } |
| } |
| |
| return 0; |
| } |
