// // 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 "helpers.h" #include "gl_headers.h" #include "CL/cl_half.h" #define CHECK_ERROR()\ {GLint __error = glGetError(); if(__error) {log_error( "GL ERROR: %s!\n", gluErrorString( err ));}} #if defined(__linux__) || defined(GL_ES_VERSION_2_0) // On linux we don't link to GLU library to avoid compatibility issues with // libstdc++ // FIXME: Implement this const GLubyte* gluErrorString (GLenum error) { const char* gl_Error = "OpenGL Error"; return (const GLubyte*)gl_Error; } #endif static void DrawQuad(void); void * CreateGLTexture2D( size_t width, size_t height, GLenum target, GLenum glFormat, GLenum internalFormat, GLenum glType, ExplicitType type, GLuint *outTextureID, int *outError, bool allocateMem, MTdata d ) { *outError = 0; GLenum err = 0; char * buffer = (char *)CreateRandomData(type, width * height * 4, d); glGenTextures( 1, outTextureID ); glBindTexture( get_base_gl_target( target ), *outTextureID ); err = glGetError(); if( err != GL_NO_ERROR ) { log_error( "ERROR: Failed to create GL texture object: %s!\n", gluErrorString( err )); *outError = -1; free( buffer ); return NULL; } #ifndef GL_ES_VERSION_2_0 glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); #endif glTexParameteri( get_base_gl_target( target ), GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( get_base_gl_target( target ), GL_TEXTURE_MAG_FILTER, GL_NEAREST ); if( get_base_gl_target( target ) == GL_TEXTURE_CUBE_MAP ) { char * temp = (char *)malloc(width * height * 4 * get_explicit_type_size( type ) * sizeof(cl_char)); if(allocateMem) memcpy( temp, buffer, width * height * 4 * get_explicit_type_size( type ) ); else memset( temp, 0, width * height * 4 * get_explicit_type_size( type ) ); glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, internalFormat, (GLsizei)width, (GLsizei)height, 0, glFormat, glType, temp ); glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, internalFormat, (GLsizei)width, (GLsizei)height, 0, glFormat, glType, temp ); glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, internalFormat, (GLsizei)width, (GLsizei)height, 0, glFormat, glType, temp ); glTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, internalFormat, (GLsizei)width, (GLsizei)height, 0, glFormat, glType, temp ); glTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, internalFormat, (GLsizei)width, (GLsizei)height, 0, glFormat, glType, temp ); glTexImage2D( GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, internalFormat, (GLsizei)width, (GLsizei)height, 0, glFormat, glType, temp ); free(temp); } else { #ifdef GLES_DEBUG log_info("- glTexImage2D : %s : %s : %d : %d : %s : %s\n", GetGLTargetName(target), GetGLFormatName(internalFormat), width, height, GetGLFormatName(glFormat), GetGLTypeName(glType)); DumpGLBuffer(glType, width, height, buffer); #endif glTexImage2D( get_base_gl_target(target), 0, internalFormat, (GLsizei)width, (GLsizei)height, 0, glFormat, glType, buffer ); } err = glGetError(); if( err != GL_NO_ERROR ) { /** In section 9.8.3.1. of the CL 1.1. spec it says that: * * If a GL texture object with an internal format from table 9.4 is successfully created by * OpenGL, then there is guaranteed to be a mapping to one of the corresponding CL image * format(s) in that table. * * Notice that some of the formats in table 9.4 are not supported in OpenGL ES 2.0. */ log_info( "Warning: Skipping %s : %s : %d : %d : %s : %s : because glTexImage2D returned %s\n", GetGLTargetName(target), GetGLFormatName(internalFormat), (int)(width), (int)(height), GetGLFormatName(glFormat), GetGLTypeName(glType), gluErrorString( err )); glDeleteTextures( 1, outTextureID ); *outTextureID = 0; *outError = 0; free( buffer ); err = glGetError(); return NULL; } #ifdef GLES_DEBUG memset(buffer, 0, width * height * 4 * get_explicit_type_size( type )); log_info("- glGetTexImage : %s : %s : %s\n", GetGLTargetName(target), GetGLFormatName(glFormat), GetGLTypeName(glType)); glGetTexImage(target, 0, glFormat, glType, buffer); DumpGLBuffer(type, width, height, buffer); err = glGetError(); if( err != GL_NO_ERROR ) { log_error( "ERROR: Unable to read data from glGetTexImage : %s : %s : %s : Error %s\n", GetGLTargetName(target), GetGLFormatName(glFormat), GetGLTypeName(glType), gluErrorString( err )); return NULL; } #endif if( !allocateMem ) { free( buffer ); return NULL; } #ifndef GL_ES_VERSION_2_0 if( glType == GL_UNSIGNED_INT_8_8_8_8_REV && glFormat == GL_BGRA && allocateMem ) { // Reverse and reorder to validate since in the // kernel the read_imagef() call always returns RGBA cl_uchar *p = (cl_uchar *)buffer; for( size_t i = 0; i < width * height; i++ ) { cl_uchar uc0 = p[i * 4 + 0]; cl_uchar uc1 = p[i * 4 + 1]; cl_uchar uc2 = p[i * 4 + 2]; cl_uchar uc3 = p[i * 4 + 3]; p[ i * 4 + 0 ] = uc2; p[ i * 4 + 1 ] = uc1; p[ i * 4 + 2 ] = uc0; p[ i * 4 + 3 ] = uc3; } } #endif return buffer; } void * CreateGLTexture3D( size_t width, size_t height, size_t depth, GLenum target, GLenum glFormat, GLenum internalFormat, GLenum glType, ExplicitType type, GLuint *outTextureID, int *outError, MTdata d, bool allocateMem) { *outError = 0; char * buffer = (char *)create_random_data( type, d, width * height * depth * 4 ); if( type == kFloat && allocateMem ) { // Re-fill the created buffer to just have [0-1] floats, since that's what it'd expect cl_float *p = (cl_float *)buffer; for( size_t i = 0; i < width * height * depth * 4; i++ ) { p[ i ] = (float) genrand_real1( d ); } } else if( !allocateMem ) memset( buffer, 0, width * height * depth * 4 * get_explicit_type_size( type ) ); glGenTextures( 1, outTextureID ); glBindTexture( target, *outTextureID ); #ifndef GL_ES_VERSION_2_0 glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); #endif glTexParameteri( target, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( target, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glGetError(); glTexImage3D( target, 0, internalFormat, (GLsizei)width, (GLsizei)height, (GLsizei)depth, 0, glFormat, glType, buffer ); GLenum err = glGetError(); if( err != GL_NO_ERROR ) { /** In section 9.8.3.1. of the CL 1.1. spec it says that: * * If a GL texture object with an internal format from table 9.4 is successfully created by * OpenGL, then there is guaranteed to be a mapping to one of the corresponding CL image * format(s) in that table. * * Notice that some of the formats in table 9.4 are not supported in OpenGL ES 2.0. */ log_info( "Warning: Skipping %s : %s : %d : %d : %s : %s : because glTexImage3D returned %s\n", GetGLTargetName(target), GetGLFormatName(internalFormat), (int)(width), (int)(height), GetGLFormatName(glFormat), GetGLTypeName(glType), gluErrorString( err )); *outError = 0; delete[] buffer; return NULL; } if( !allocateMem ) { delete [] buffer; return NULL; } #ifndef GL_ES_VERSION_2_0 if( glType == GL_UNSIGNED_INT_8_8_8_8_REV && glFormat == GL_BGRA && allocateMem ) { // Reverse and reorder to validate since in the // kernel the read_imagef() call always returns RGBA cl_uchar *p = (cl_uchar *)buffer; for( size_t i = 0; i < width * height * depth; i++ ) { cl_uchar uc0 = p[i * 4 + 0]; cl_uchar uc1 = p[i * 4 + 1]; cl_uchar uc2 = p[i * 4 + 2]; cl_uchar uc3 = p[i * 4 + 3]; p[ i * 4 + 0 ] = uc2; p[ i * 4 + 1 ] = uc1; p[ i * 4 + 2 ] = uc0; p[ i * 4 + 3 ] = uc3; } } #endif return buffer; } void * ReadGLTexture( GLenum glTarget, GLuint glTexture, GLenum glFormat, GLenum glInternalFormat, GLenum glType, ExplicitType typeToReadAs, size_t outWidth, size_t outHeight ) { // Read results from the GL texture glBindTexture(get_base_gl_target(glTarget), glTexture); GLenum readBackFormat = GL_RGBA; GLenum readBackType = glType; glFramebufferWrapper glFramebuffer; glRenderbufferWrapper glRenderbuffer; size_t outBytes = outWidth * outHeight * 4 * GetGLTypeSize(readBackType); cl_char *outBuffer = (cl_char *)malloc( outBytes ); GLenum err = 0; memset(outBuffer, 0, outBytes); glGenFramebuffersEXT( 1, &glFramebuffer ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, glFramebuffer ); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, glTarget, glTexture, 0); err = glGetError(); if (err != GL_NO_ERROR) { log_error("Failed to attach texture to FBO!\n"); return NULL; } glReadPixels( 0, 0, (GLsizei)outWidth, (GLsizei)outHeight, readBackFormat, readBackType, outBuffer ); #ifdef GLES_DEBUG log_info( "- glGetTexImage: %s : %s : %s \n", GetGLTargetName( glTarget), GetGLFormatName(readBackFormat), GetGLTypeName(readBackType)); DumpGLBuffer(readBackType, outWidth, outHeight, (void *)outBuffer); #endif return (void *)outBuffer; } int CreateGLRenderbufferRaw( GLsizei width, GLsizei height, GLenum attachment, GLenum rbFormat, GLenum rbType, GLuint *outFramebuffer, GLuint *outRenderbuffer ) { GLenum err = 0; // Generate a renderbuffer and bind glGenRenderbuffersEXT( 1, outRenderbuffer ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, *outRenderbuffer ); // Allocate storage to the renderbuffer glGetError(); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, rbFormat, (GLsizei)width, (GLsizei)height ); err = glGetError(); if( err != GL_NO_ERROR ) { log_error("Failed to allocate render buffer storage!\n"); return 1701; } GLint realInternalFormat; glGetRenderbufferParameterivEXT( GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_INTERNAL_FORMAT_EXT, &realInternalFormat ); rbFormat = realInternalFormat; #ifdef GLES_DEBUG GLint rsize, gsize, bsize, asize; glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_RED_SIZE_EXT,&rsize); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_GREEN_SIZE_EXT,&gsize); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_BLUE_SIZE_EXT,&bsize); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_ALPHA_SIZE_EXT,&asize); log_info("Renderbuffer internal format requested: %s actual: %s sizes: r=%d g=%d b=%d a=%d\n", GetGLFormatName( internalFormat ), GetGLFormatName( realInternalFormat ), rsize, gsize, bsize, asize ); #endif // Create and bind a framebuffer to render with glGenFramebuffersEXT( 1, outFramebuffer ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, *outFramebuffer ); if( err != GL_NO_ERROR ) { log_error( "ERROR: Unable to bind framebuffer : Error %s\n", gluErrorString( err )); return -1; } // Attach to the framebuffer glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, attachment, GL_RENDERBUFFER_EXT, *outRenderbuffer ); err = glGetError(); GLint status = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT ); if( status != GL_FRAMEBUFFER_COMPLETE_EXT ) { log_error( "ERROR: Unable to attach renderbuffer to framebuffer (%s, status %x)\n", gluErrorString( err ), (int)status ); return -1; } return 0; } static void DrawQuad(void) { const char *vssrc = "varying mediump vec2 texCoord;\n" "attribute vec2 inPosition;\n" "void main() {\n" " texCoord = vec2((inPosition.x+1.0)/2.0, (inPosition.y+1.0)/2.0);\n" " gl_Position = vec4(inPosition.x, inPosition.y, 0.0, 1.0);\n" "}\n"; const char *fssrc = "uniform sampler2D tex;\n" "varying mediump vec2 texCoord;\n" "void main() {\n" " gl_FragColor = texture2D(tex, texCoord);\n" "}\n"; GLuint vs, fs, program; GLuint positionIdx = 0; GLfloat x1 = -1.0f, x2 = 1.0f, y1 = -1.0f, y2 = 1.0f; GLfloat vertices[4][2]; vertices[0][0] = x1; vertices[0][1] = y1; vertices[1][0] = x2; vertices[1][1] = y1; vertices[2][0] = x1; vertices[2][1] = y2; vertices[3][0] = x2; vertices[3][1] = y2; vs = glCreateShader(GL_VERTEX_SHADER); fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(vs, 1, &vssrc, NULL); glShaderSource(fs, 1, &fssrc, NULL); glCompileShader(vs); glCompileShader(fs); program = glCreateProgram(); glAttachShader(program, vs); glAttachShader(program, fs); glLinkProgram(program); glUseProgram(program); positionIdx = glGetAttribLocation(program, "inPosition"); glEnableVertexAttribArray(positionIdx); glVertexAttribPointer(positionIdx, 2, GL_FLOAT, GL_FALSE, 0, vertices); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glUseProgram(0); glDeleteProgram(program); glDeleteShader(vs); glDeleteShader(fs); } void * CreateGLRenderbuffer( GLsizei width, GLsizei height, GLenum attachment, GLenum rbFormat, GLenum rbType, GLenum texFormat, GLenum texType, ExplicitType type, GLuint *outFramebuffer, GLuint *outRenderbuffer, int *outError, MTdata d, bool allocateMem ) { *outError = CreateGLRenderbufferRaw( width, height, attachment, rbFormat, rbType, outFramebuffer, outRenderbuffer ); if( *outError != 0 ) return NULL; GLenum err = 0; // Generate a renderbuffer and bind glGenRenderbuffersEXT( 1, outRenderbuffer ); glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, *outRenderbuffer ); // Allocate storage to the renderbuffer glGetError(); glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, rbFormat, (GLsizei)width, (GLsizei)height ); err = glGetError(); if( err != GL_NO_ERROR ) { *outError = 1701; log_error("Failed to allocate render buffer storage!\n"); return NULL; } GLint realInternalFormat; glGetRenderbufferParameterivEXT( GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_INTERNAL_FORMAT_EXT, &realInternalFormat ); rbFormat = realInternalFormat; #ifdef GLES_DEBUG GLint rsize, gsize, bsize, asize; glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_RED_SIZE_EXT,&rsize); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_GREEN_SIZE_EXT,&gsize); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_BLUE_SIZE_EXT,&bsize); glGetRenderbufferParameterivEXT(GL_RENDERBUFFER_EXT, GL_RENDERBUFFER_ALPHA_SIZE_EXT,&asize); log_info("Renderbuffer internal format requested: %s actual: %s sizes: r=%d g=%d b=%d a=%d\n", GetGLFormatName( internalFormat ), GetGLFormatName( realInternalFormat ), rsize, gsize, bsize, asize ); #endif // Create and bind a framebuffer to render with glGenFramebuffersEXT( 1, outFramebuffer ); glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, *outFramebuffer ); err = glGetError(); if( err != GL_NO_ERROR ) { log_error( "ERROR: Unable to bind framebuffer : Error %s\n", gluErrorString( err )); *outError = -1; return NULL; } // Attach to the framebuffer glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, attachment, GL_RENDERBUFFER_EXT, *outRenderbuffer ); CHECK_ERROR(); GLint status = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT ); if( status != GL_FRAMEBUFFER_COMPLETE_EXT ) { *outError = -1; log_error( "ERROR: Unable to attach renderbuffer to framebuffer (%s, status %x)\n", gluErrorString( err ), (int)status ); return NULL; } void* buffer = CreateRandomData(type, width * height * 4, d); #ifdef GLES_DEBUG log_info( "- Fillling renderbuffer: %d : %d : %s : %s \n", (int)width, (int)height, GetGLFormatName(glFormat), GetGLTypeName(glType)); DumpGLBuffer(glType, (int)width, (int)height, (void*)buffer); #endif CHECK_ERROR(); // Fill a texture with our input data glTextureWrapper texture; glGenTextures( 1, &texture ); glBindTexture( GL_TEXTURE_2D, texture ); CHECK_ERROR(); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); CHECK_ERROR(); glTexImage2D( GL_TEXTURE_2D, 0, texFormat, width, height, 0, texFormat, texType, buffer ); CHECK_ERROR(); // Render fullscreen textured quad glViewport(0, 0, width, height); DrawQuad(); CHECK_ERROR(); // Read back the data in the renderbuffer memset(buffer, 0, width * height * 4 * get_explicit_type_size( type )); glReadPixels( 0, 0, (GLsizei)width, (GLsizei)height, texFormat, texType, buffer ); err = glGetError(); if( err != GL_NO_ERROR ) { log_error( "ERROR: Unable to read data via glReadPixels : %d : %d : %s : %s : Error %s\n", (int)width, (int)height, GetGLFormatName(texFormat), GetGLTypeName(texType), gluErrorString( err )); *outError = -1; } #ifdef GLES_DEBUG log_info( "- glReadPixels: %d : %d : %s : %s \n", (int)width, (int)height, GetGLFormatName(glFormat), GetGLTypeName(glType)); DumpGLBuffer(glType, (int)width, (int)height, (void*)buffer); #endif if( !allocateMem ) { free( buffer ); return NULL; } #ifndef GL_ES_VERSION_2_0 if( glType == GL_UNSIGNED_INT_8_8_8_8_REV && glFormat == GL_BGRA && allocateMem ) { // Reverse and reorder to validate since in the // kernel the read_imagef() call always returns RGBA cl_uchar *p = (cl_uchar *)buffer; for( size_t i = 0; i < (size_t)width * height; i++ ) { cl_uchar uc0 = p[i * 4 + 0]; cl_uchar uc1 = p[i * 4 + 1]; cl_uchar uc2 = p[i * 4 + 2]; cl_uchar uc3 = p[i * 4 + 3]; p[ i * 4 + 0 ] = uc2; p[ i * 4 + 1 ] = uc1; p[ i * 4 + 2 ] = uc0; p[ i * 4 + 3 ] = uc3; } } #endif return buffer; } void * ReadGLRenderbuffer( GLuint glFramebuffer, GLuint glRenderbuffer, GLenum attachment, GLenum rbFormat, GLenum rbType, GLenum texFormat, GLenum texType, ExplicitType typeToReadAs, size_t outWidth, size_t outHeight ) { glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, glFramebuffer ); glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, attachment, GL_RENDERBUFFER_EXT, glRenderbuffer ); // Attach to the framebuffer GLint err = glGetError(); if( glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT ) != GL_FRAMEBUFFER_COMPLETE_EXT ) { log_error( "ERROR: Unable to attach renderbuffer to framebuffer (%s)\n", gluErrorString( err ) ); return NULL; } // Read results from the GL renderbuffer #ifdef GLES_DEBUG log_info( "- Reading back from GL: %d x %d : %s : %s : %s\n", (int)outWidth, (int)outHeight, GetGLFormatName( glInternalFormat ), GetGLFormatName( glFormat ), GetGLTypeName( glType )); #endif GLenum readBackFormat = GL_RGBA; GLenum readBackType = texType; size_t outBytes = outWidth * outHeight * 4 * GetGLTypeSize(readBackType); void *outBuffer = malloc( outBytes ); memset(outBuffer, 0, outBytes); glReadPixels( 0, 0, (GLsizei)outWidth, (GLsizei)outHeight, readBackFormat, readBackType, outBuffer ); #ifdef GLES_DEBUG log_info( "- glReadPixels: %d : %d : %s : %s \n", (int)outWidth, (int)outHeight, GetGLFormatName(readBackFormat), GetGLTypeName(readBackType)); DumpGLBuffer(readBackType, outWidth, outHeight, outBuffer); #endif return (void *)outBuffer; } GLenum GetGLFormat(GLenum internalFormat) { GLenum glFormat; switch (internalFormat) { case GL_BGRA: #ifndef GL_ES_VERSION_2_0 case GL_RGBA8: case GL_RGBA16: case GL_RGBA32F_ARB: #endif glFormat = GL_RGBA; break; #ifndef GL_ES_VERSION_2_0 case GL_RGBA8I_EXT: case GL_RGBA16I_EXT: case GL_RGBA32I_EXT: case GL_RGBA8UI_EXT: case GL_RGBA16UI_EXT: case GL_RGBA32UI_EXT: glFormat = GL_RGBA_INTEGER_EXT; break; #endif default: glFormat = GL_RGBA; break; } return glFormat; } GLenum GetGLTypeForExplicitType(ExplicitType type) { switch( type ) { case kFloat: return GL_FLOAT; case kInt: return GL_INT; case kUInt: return GL_UNSIGNED_INT; case kShort: return GL_SHORT; case kUShort: return GL_UNSIGNED_SHORT; case kChar: return GL_BYTE; case kUChar: return GL_UNSIGNED_BYTE; case kHalf: #if defined( __APPLE__ ) return GL_HALF_FLOAT; #else return GL_HALF_FLOAT_ARB; #endif default: return GL_INT; }; } size_t GetGLTypeSize(GLenum type) { switch( type ) { case GL_FLOAT: return sizeof(GLfloat); case GL_INT: return sizeof(GLint); case GL_UNSIGNED_INT: return sizeof(GLuint); case GL_SHORT: return sizeof(GLshort); case GL_UNSIGNED_SHORT: return sizeof(GLushort); case GL_BYTE: return sizeof(GLbyte); case GL_UNSIGNED_BYTE: return sizeof(GLubyte); #if defined( __APPLE__ ) case GL_HALF_FLOAT: #else case GL_HALF_FLOAT_ARB: #endif return sizeof(GLhalf); default: return kFloat; }; } ExplicitType GetExplicitTypeForGLType(GLenum type) { switch( type ) { case GL_FLOAT: return kFloat; case GL_INT: return kInt; case GL_UNSIGNED_INT: return kUInt; case GL_SHORT: return kShort; case GL_UNSIGNED_SHORT: return kUShort; case GL_BYTE: return kChar; case GL_UNSIGNED_BYTE: return kUChar; #if defined( __APPLE__ ) case GL_HALF_FLOAT: #else case GL_HALF_FLOAT_ARB: #endif return kHalf; default: return kFloat; }; } GLenum get_base_gl_target( GLenum target ) { switch( target ) { 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: return GL_TEXTURE_CUBE_MAP; default: return target; } } const char *GetGLTypeName( GLenum type ) { switch( type ) { case GL_BYTE: return "GL_BYTE"; case GL_UNSIGNED_BYTE: return "GL_UNSIGNED_BYTE"; case GL_INT: return "GL_INT"; case GL_UNSIGNED_INT: return "GL_UNSIGNED_INT"; case GL_SHORT: return "GL_SHORT"; case GL_UNSIGNED_SHORT: return "GL_UNSIGNED_SHORT"; #if defined( __APPLE__ ) case GL_HALF_FLOAT: return "GL_HALF_FLOAT"; #else case GL_HALF_FLOAT_ARB: return "GL_HALF_FLOAT_ARB"; #endif case GL_FLOAT: return "GL_FLOAT"; #ifndef GL_ES_VERSION_2_0 case GL_UNSIGNED_INT_8_8_8_8: return "GL_UNSIGNED_INT_8_8_8_8"; case GL_UNSIGNED_INT_8_8_8_8_REV: return "GL_UNSIGNED_INT_8_8_8_8_REV"; #endif default: { static char foo[ 128 ]; sprintf( foo, "(Unknown:0x%08x)", (int)type ); return foo; } } } const char *GetGLTargetName( GLenum tgt ) { if( tgt == GL_TEXTURE_2D ) return "GL_TEXTURE_2D"; if( tgt == GL_TEXTURE_3D ) return "GL_TEXTURE_3D"; #ifndef GL_ES_VERSION_2_0 if( tgt == GL_TEXTURE_RECTANGLE_EXT ) return "GL_TEXTURE_RECTANGLE_EXT"; #endif if( tgt == GL_TEXTURE_CUBE_MAP_POSITIVE_X ) return "GL_TEXTURE_CUBE_MAP_POSITIVE_X"; if( tgt == GL_TEXTURE_CUBE_MAP_POSITIVE_Y ) return "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"; if( tgt == GL_TEXTURE_CUBE_MAP_POSITIVE_Z ) return "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"; if( tgt == GL_TEXTURE_CUBE_MAP_NEGATIVE_X ) return "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"; if( tgt == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y ) return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"; if( tgt == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z ) return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"; return ""; } const char *GetGLAttachmentName( GLenum att ) { if( att == GL_COLOR_ATTACHMENT0_EXT ) return "GL_COLOR_ATTACHMENT0_EXT"; #ifndef GL_ES_VERSION_2_0 if( att == GL_COLOR_ATTACHMENT1_EXT ) return "GL_COLOR_ATTACHMENT1_EXT"; if( att == GL_COLOR_ATTACHMENT2_EXT ) return "GL_COLOR_ATTACHMENT2_EXT"; if( att == GL_COLOR_ATTACHMENT3_EXT ) return "GL_COLOR_ATTACHMENT3_EXT"; if( att == GL_COLOR_ATTACHMENT4_EXT ) return "GL_COLOR_ATTACHMENT4_EXT"; if( att == GL_COLOR_ATTACHMENT5_EXT ) return "GL_COLOR_ATTACHMENT5_EXT"; if( att == GL_COLOR_ATTACHMENT6_EXT ) return "GL_COLOR_ATTACHMENT6_EXT"; if( att == GL_COLOR_ATTACHMENT7_EXT ) return "GL_COLOR_ATTACHMENT7_EXT"; if( att == GL_COLOR_ATTACHMENT8_EXT ) return "GL_COLOR_ATTACHMENT8_EXT"; #endif if( att == GL_DEPTH_ATTACHMENT_EXT ) return "GL_DEPTH_ATTACHMENT_EXT"; return ""; } const char *GetGLBaseFormatName( GLenum baseformat ) { switch( baseformat ) { case GL_RGBA: return "GL_RGBA"; #ifdef GL_ES_VERSION_2_0 case GL_BGRA_EXT: return "GL_BGRA_EXT"; #else case GL_RGBA8: return "GL_RGBA"; case GL_RGBA16: return "GL_RGBA"; case GL_BGRA: return "GL_BGRA"; case GL_RGBA8I_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_RGBA16I_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_RGBA32I_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_RGBA8UI_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_RGBA16UI_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_RGBA32UI_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_RGBA32F_ARB: return "GL_RGBA"; case GL_RGBA_INTEGER_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_ALPHA4: return "GL_ALPHA"; case GL_ALPHA8: return "GL_ALPHA"; case GL_ALPHA12: return "GL_ALPHA"; case GL_ALPHA16: return "GL_ALPHA"; case GL_LUMINANCE4: return "GL_LUMINANCE"; case GL_LUMINANCE8: return "GL_LUMINANCE"; case GL_LUMINANCE12: return "GL_LUMINANCE"; case GL_LUMINANCE16: return "GL_LUMINANCE"; case GL_LUMINANCE4_ALPHA4: return "GL_LUMINANCE_ALPHA"; case GL_LUMINANCE6_ALPHA2: return "GL_LUMINANCE_ALPHA"; case GL_LUMINANCE8_ALPHA8: return "GL_LUMINANCE_ALPHA"; case GL_LUMINANCE12_ALPHA4: return "GL_LUMINANCE_ALPHA"; case GL_LUMINANCE12_ALPHA12: return "GL_LUMINANCE_ALPHA"; case GL_LUMINANCE16_ALPHA16: return "GL_LUMINANCE_ALPHA"; case GL_INTENSITY: return "GL_INTENSITY"; case GL_INTENSITY4: return "GL_INTENSITY"; case GL_INTENSITY8: return "GL_INTENSITY"; case GL_INTENSITY12: return "GL_INTENSITY"; case GL_INTENSITY16: return "GL_INTENSITY"; case GL_R3_G3_B2: return "GL_RGB"; case GL_RGB4: return "GL_RGB"; case GL_RGB5: return "GL_RGB"; case GL_RGB8: return "GL_RGB"; case GL_RGB10: return "GL_RGB"; case GL_RGB12: return "GL_RGB"; case GL_RGB16: return "GL_RGB"; case GL_RGBA2: return "GL_RGBA"; case GL_RGBA4: return "GL_RGBA"; case GL_RGB5_A1: return "GL_RGBA"; case GL_RGB10_A2: return "GL_RGBA"; case GL_RGBA12: return "GL_RGBA"; #endif default: { static char foo[ 128 ]; sprintf( foo, "(Unknown:0x%08x)", (int)baseformat ); return foo; } } } const char *GetGLFormatName( GLenum format ) { switch( format ) { case GL_RGBA: return "GL_RGBA"; #ifdef GL_ES_VERSION_2_0 case GL_BGRA_EXT: return "GL_BGRA_EXT"; #else case GL_RGBA8: return "GL_RGBA8"; case GL_RGBA16: return "GL_RGBA16"; case GL_BGRA: return "GL_BGRA"; case GL_RGBA8I_EXT: return "GL_RGBA8I_EXT"; case GL_RGBA16I_EXT: return "GL_RGBA16I_EXT"; case GL_RGBA32I_EXT: return "GL_RGBA32I_EXT"; case GL_RGBA8UI_EXT: return "GL_RGBA8UI_EXT"; case GL_RGBA16UI_EXT: return "GL_RGBA16UI_EXT"; case GL_RGBA32UI_EXT: return "GL_RGBA32UI_EXT"; case GL_RGBA32F_ARB: return "GL_RGBA32F_ARB"; case GL_RGBA_INTEGER_EXT: return "GL_RGBA_INTEGER_EXT"; case GL_ALPHA4: return "GL_ALPHA4"; case GL_ALPHA8: return "GL_ALPHA8"; case GL_ALPHA12: return "GL_ALPHA12"; case GL_ALPHA16: return "GL_ALPHA16"; case GL_LUMINANCE4: return "GL_LUMINANCE4"; case GL_LUMINANCE8: return "GL_LUMINANCE8"; case GL_LUMINANCE12: return "GL_LUMINANCE12"; case GL_LUMINANCE16: return "GL_LUMINANCE16"; case GL_LUMINANCE4_ALPHA4: return "GL_LUMINANCE4_ALPHA4"; case GL_LUMINANCE6_ALPHA2: return "GL_LUMINANCE6_ALPHA2"; case GL_LUMINANCE8_ALPHA8: return "GL_LUMINANCE8_ALPHA8"; case GL_LUMINANCE12_ALPHA4: return "GL_LUMINANCE12_ALPHA4"; case GL_LUMINANCE12_ALPHA12: return "GL_LUMINANCE12_ALPHA12"; case GL_LUMINANCE16_ALPHA16: return "GL_LUMINANCE16_ALPHA16"; case GL_INTENSITY: return "GL_INTENSITY"; case GL_INTENSITY4: return "GL_INTENSITY4"; case GL_INTENSITY8: return "GL_INTENSITY8"; case GL_INTENSITY12: return "GL_INTENSITY12"; case GL_INTENSITY16: return "GL_INTENSITY16"; case GL_R3_G3_B2: return "GL_R3_G3_B2"; case GL_RGB4: return "GL_RGB4"; case GL_RGB5: return "GL_RGB5"; case GL_RGB8: return "GL_RGB8"; case GL_RGB10: return "GL_RGB10"; case GL_RGB12: return "GL_RGB12"; case GL_RGB16: return "GL_RGB16"; case GL_RGBA2: return "GL_RGBA2"; case GL_RGBA4: return "GL_RGBA4"; case GL_RGB5_A1: return "GL_RGB5_A1"; case GL_RGB10_A2: return "GL_RGB10_A2"; case GL_RGBA12: return "GL_RGBA12"; #endif case GL_INT: return "GL_INT"; case GL_UNSIGNED_INT: return "GL_UNSIGNED_INT"; case GL_SHORT: return "GL_SHORT"; case GL_UNSIGNED_SHORT: return "GL_UNSIGNED_SHORT"; case GL_BYTE: return "GL_BYTE"; case GL_UNSIGNED_BYTE: return "GL_UNSIGNED_BYTE"; case GL_FLOAT: return "GL_FLOAT"; #ifdef GL_ES_VERSION_2_0 case GL_HALF_FLOAT_OES: return "GL_HALF_FLOAT_OES"; #else #if defined( __APPLE__ ) case GL_HALF_FLOAT: return "GL_HALF_FLOAT"; #else case GL_HALF_FLOAT_ARB: return "GL_HALF_FLOAT_ARB"; #endif #endif default: { static char foo[ 128 ]; sprintf( foo, "(Unknown:0x%08x)", (int)format ); return foo; } } } void* CreateRandomData( ExplicitType type, size_t count, MTdata d ) { switch(type) { case (kChar): { cl_char *p = (cl_char *)malloc(count * sizeof(cl_char)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[ i ] = (cl_char)genrand_int32(d); } return (void*)p; } case (kUChar): { cl_uchar *p = (cl_uchar *)malloc(count * sizeof(cl_uchar)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[ i ] = (cl_uchar)genrand_int32(d); } return (void*)p; } case (kShort): { cl_short *p = (cl_short *)malloc(count * sizeof(cl_short)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[ i ] = (cl_short)genrand_int32(d); } return (void*)p; } case (kUShort): { cl_ushort *p = (cl_ushort *)malloc(count * sizeof(cl_ushort)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[ i ] = (cl_ushort)genrand_int32(d); } return (void*)p; } case (kInt): { cl_int *p = (cl_int *)malloc(count * sizeof(cl_int)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[ i ] = (cl_int)genrand_int32(d); } return (void*)p; } case (kUInt): { cl_uint *p = (cl_uint *)malloc(count * sizeof(cl_uint)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[ i ] = (cl_uint)genrand_int32(d); } return (void*)p; } case (kFloat): { cl_float *p = (cl_float *)malloc(count * sizeof(cl_float)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[ i ] = get_random_float( 0.f, 1.f, d ); } return (void*)p; } /* added support for half floats */ case (kHalf): { cl_half *p = (cl_half *)malloc(count * sizeof(cl_half)); if(!p) return 0; for( size_t i = 0; i < count; i++ ) { p[i] = cl_half_from_float(get_random_float(0.f, 1.f, d), CL_HALF_RTE); } return (void*)p; } default: { log_error("Invalid explicit type specified for create random data!\n"); return 0; } } return 0; } void DumpGLBuffer(GLenum type, size_t width, size_t height, void* buffer) { size_t i; size_t count = width * height; if(type == GL_BYTE) { cl_char* p = (cl_char*)buffer; for(i = 0; i < count; i++) log_info("[%4d] %3d %3d %3d %3d\n", (unsigned int)(i), p[i* 4 + 0], p[i* 4 + 1], p[i* 4 + 2], p[i* 4 + 3]); } else if(type == GL_UNSIGNED_BYTE) { cl_uchar* p = (cl_uchar*)buffer; for(i = 0; i < count; i++) log_info("[%4d] %3d %3d %3d %3d\n", (unsigned int)(i), p[i* 4 + 0], p[i* 4 + 1], p[i* 4 + 2], p[i* 4 + 3]); } else if(type == GL_INT) { cl_int* p = (cl_int*)buffer; for(i = 0; i < count; i++) log_info("[%4d] %3d %3d %3d %3d\n", (unsigned int)(i), p[i* 4 + 0], p[i* 4 + 1], p[i* 4 + 2], p[i* 4 + 3]); } else if(type == GL_UNSIGNED_INT) { cl_uint* p = (cl_uint*)buffer; for(i = 0; i < count; i++) log_info("[%4d] %3d %3d %3d %3d\n", (unsigned int)(i), p[i* 4 + 0], p[i* 4 + 1], p[i* 4 + 2], p[i* 4 + 3]); } else if(type == GL_SHORT) { cl_short* p = (cl_short*)buffer; for(i = 0; i < count; i++) log_info("[%4d] %3d %3d %3d %3d\n", (unsigned int)(i), p[i* 4 + 0], p[i* 4 + 1], p[i* 4 + 2], p[i* 4 + 3]); } else if(type == GL_UNSIGNED_SHORT) { cl_ushort* p = (cl_ushort*)buffer; for(i = 0; i < count; i++) log_info("[%4d] %3d %3d %3d %3d\n", (unsigned int)(i), p[i* 4 + 0], p[i* 4 + 1], p[i* 4 + 2], p[i* 4 + 3]); } else if(type == GL_FLOAT) { cl_float* p = (cl_float*)buffer; for(i = 0; i < count; i++) log_info("[%4d] %#f %#f %#f %#f\n", (unsigned int)(i), p[i* 4 + 0], p[i* 4 + 1], p[i* 4 + 2], p[i* 4 + 3]); } } #if defined(_WIN32) #include GLboolean gluCheckExtension(const GLubyte *extName, const GLubyte *extString) { const size_t len = strlen((const char*)extName); const char* str = (const char*)extString; while (str != NULL) { str = strstr(str, (const char*)extName); if (str == NULL) { break; } if ((str > (const char*)extString || str[-1] == ' ') && (str[len] == ' ' || str[len] == '\0')) { return GL_TRUE; } str = strchr(str + len, ' '); } return GL_FALSE; } #endif // Function pointers for the GL/CL calls clCreateFromGLBuffer_fn clCreateFromGLBuffer_ptr; clCreateFromGLTexture_fn clCreateFromGLTexture_ptr; clCreateFromGLRenderbuffer_fn clCreateFromGLRenderbuffer_ptr; clGetGLObjectInfo_fn clGetGLObjectInfo_ptr; clGetGLTextureInfo_fn clGetGLTextureInfo_ptr; clEnqueueAcquireGLObjects_fn clEnqueueAcquireGLObjects_ptr; clEnqueueReleaseGLObjects_fn clEnqueueReleaseGLObjects_ptr; int init_clgl_ext(cl_platform_id platform_id) { // Create the function pointer table clCreateFromGLBuffer_ptr = (clCreateFromGLBuffer_fn)clGetExtensionFunctionAddressForPlatform(platform_id, "clCreateFromGLBuffer"); if (clCreateFromGLBuffer_ptr == NULL) { log_error("clGetExtensionFunctionAddressForPlatform(clCreateFromGLBuffer) returned NULL.\n"); return -1; } clCreateFromGLTexture_ptr = (clCreateFromGLTexture_fn)clGetExtensionFunctionAddressForPlatform(platform_id, "clCreateFromGLTexture"); if (clCreateFromGLTexture_ptr == NULL) { log_error("clGetExtensionFunctionAddressForPlatform(clCreateFromGLTexture) returned NULL.\n"); return -1; } clCreateFromGLRenderbuffer_ptr = (clCreateFromGLRenderbuffer_fn)clGetExtensionFunctionAddressForPlatform(platform_id, "clCreateFromGLRenderbuffer"); if (clCreateFromGLRenderbuffer_ptr == NULL) { log_error("clGetExtensionFunctionAddressForPlatform(clCreateFromGLRenderbuffer) returned NULL.\n"); return -1; } clGetGLObjectInfo_ptr = (clGetGLObjectInfo_fn)clGetExtensionFunctionAddressForPlatform(platform_id, "clGetGLObjectInfo"); if (clGetGLObjectInfo_ptr == NULL) { log_error("clGetExtensionFunctionAddressForPlatform(clGetGLObjectInfo) returned NULL.\n"); return -1; } clGetGLTextureInfo_ptr = (clGetGLTextureInfo_fn)clGetExtensionFunctionAddressForPlatform(platform_id, "clGetGLTextureInfo"); if (clGetGLTextureInfo_ptr == NULL) { log_error("clGetExtensionFunctionAddressForPlatform(clGetGLTextureInfo) returned NULL.\n"); return -1; } clEnqueueAcquireGLObjects_ptr = (clEnqueueAcquireGLObjects_fn)clGetExtensionFunctionAddressForPlatform(platform_id, "clEnqueueAcquireGLObjects"); if (clEnqueueAcquireGLObjects_ptr == NULL) { log_error("clGetExtensionFunctionAddressForPlatform(clEnqueueAcquireGLObjects) returned NULL.\n"); return -1; } clEnqueueReleaseGLObjects_ptr = (clEnqueueReleaseGLObjects_fn)clGetExtensionFunctionAddressForPlatform(platform_id, "clEnqueueReleaseGLObjects"); if (clEnqueueReleaseGLObjects_ptr == NULL) { log_error("clGetExtensionFunctionAddressForPlatform(clEnqueueReleaseGLObjects) returned NULL.\n"); return -1; } return 0; }