| // |
| // 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; |
| } |