You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
478 lines
19 KiB
478 lines
19 KiB
//
|
|
// 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>
|
|
#include <CL/cl_gl.h>
|
|
#endif
|
|
|
|
#if defined (__linux__)
|
|
GLboolean
|
|
gluCheckExtension(const GLubyte *extension, const GLubyte *extensions)
|
|
{
|
|
const GLubyte *start;
|
|
GLubyte *where, *terminator;
|
|
|
|
/* Extension names should not have spaces. */
|
|
where = (GLubyte *) strchr((const char*)extension, ' ');
|
|
if (where || *extension == '\0')
|
|
return 0;
|
|
/* It takes a bit of care to be fool-proof about parsing the
|
|
OpenGL extensions string. Don't be fooled by sub-strings,
|
|
etc. */
|
|
start = extensions;
|
|
for (;;) {
|
|
where = (GLubyte *) strstr((const char *) start, (const char*) extension);
|
|
if (!where)
|
|
break;
|
|
terminator = where + strlen((const char*) extension);
|
|
if (where == start || *(where - 1) == ' ')
|
|
if (*terminator == ' ' || *terminator == '\0')
|
|
return 1;
|
|
start = terminator;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
// This is defined in the write common code:
|
|
extern int test_cl_image_write( cl_context context, cl_command_queue queue,
|
|
GLenum target, cl_mem clImage, size_t width, size_t height, size_t depth,
|
|
cl_image_format *outFormat, ExplicitType *outType, void **outSourceBuffer,
|
|
MTdata d, bool supports_half );
|
|
|
|
extern int test_cl_image_read( cl_context context, cl_command_queue queue,
|
|
GLenum gl_target, cl_mem image, size_t width, size_t height, size_t depth, size_t sampleNum,
|
|
cl_image_format *outFormat, ExplicitType *outType, void **outResultBuffer );
|
|
|
|
extern int supportsHalf(cl_context context, bool* supports_half);
|
|
|
|
static int test_attach_renderbuffer_read_image( cl_context context, cl_command_queue queue, GLenum glTarget, GLuint glRenderbuffer,
|
|
size_t imageWidth, size_t imageHeight, cl_image_format *outFormat, ExplicitType *outType, void **outResultBuffer )
|
|
{
|
|
int error;
|
|
|
|
// Create a CL image from the supplied GL renderbuffer
|
|
cl_mem image = (*clCreateFromGLRenderbuffer_ptr)( context, CL_MEM_READ_ONLY, glRenderbuffer, &error );
|
|
if( error != CL_SUCCESS )
|
|
{
|
|
print_error( error, "Unable to create CL image from GL renderbuffer" );
|
|
return error;
|
|
}
|
|
|
|
return test_cl_image_read( context, queue, glTarget, image, imageWidth,
|
|
imageHeight, 1, 1, outFormat, outType, outResultBuffer );
|
|
}
|
|
|
|
int test_renderbuffer_read_image( cl_context context, cl_command_queue queue,
|
|
GLsizei width, GLsizei height, GLenum attachment,
|
|
GLenum format, GLenum internalFormat,
|
|
GLenum glType, ExplicitType type, MTdata d )
|
|
{
|
|
int error;
|
|
|
|
if( type == kHalf )
|
|
if( DetectFloatToHalfRoundingMode(queue) )
|
|
return 1;
|
|
|
|
// Create the GL renderbuffer
|
|
glFramebufferWrapper glFramebuffer;
|
|
glRenderbufferWrapper glRenderbuffer;
|
|
void *tmp = CreateGLRenderbuffer( width, height, attachment, format, internalFormat, glType, type, &glFramebuffer, &glRenderbuffer, &error, d, true );
|
|
BufferOwningPtr<char> inputBuffer(tmp);
|
|
if( error != 0 )
|
|
{
|
|
if ((format == GL_RGBA_INTEGER_EXT) && (!CheckGLIntegerExtensionSupport()))
|
|
{
|
|
log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. Skipping test.\n");
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return error;
|
|
}
|
|
}
|
|
|
|
// Run and get the results
|
|
cl_image_format clFormat;
|
|
ExplicitType actualType;
|
|
char *outBuffer;
|
|
error = test_attach_renderbuffer_read_image( context, queue, attachment, glRenderbuffer, width, height, &clFormat, &actualType, (void **)&outBuffer );
|
|
if( error != 0 )
|
|
return error;
|
|
BufferOwningPtr<char> actualResults(outBuffer);
|
|
|
|
log_info( "- Read [%4d x %4d] : GL renderbuffer : %s : %s : %s => CL Image : %s : %s \n", width, height,
|
|
GetGLFormatName( format ), GetGLFormatName( internalFormat ), GetGLTypeName( glType),
|
|
GetChannelOrderName( clFormat.image_channel_order ), GetChannelTypeName( clFormat.image_channel_data_type ));
|
|
|
|
#ifdef DEBUG
|
|
log_info("- start read GL data -- \n");
|
|
DumpGLBuffer(glType, width, height, actualResults);
|
|
log_info("- end read GL data -- \n");
|
|
#endif
|
|
|
|
// We have to convert our input buffer to the returned type, so we can validate.
|
|
BufferOwningPtr<char> convertedInput(convert_to_expected( inputBuffer, width * height, type, actualType, get_channel_order_channel_count(clFormat.image_channel_order) ));
|
|
|
|
#ifdef DEBUG
|
|
log_info("- start input data -- \n");
|
|
DumpGLBuffer(GetGLTypeForExplicitType(actualType), width, height, convertedInput);
|
|
log_info("- end input data -- \n");
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
log_info("- start converted data -- \n");
|
|
DumpGLBuffer(GetGLTypeForExplicitType(actualType), width, height, actualResults);
|
|
log_info("- end converted data -- \n");
|
|
#endif
|
|
|
|
// Now we validate
|
|
int valid = 0;
|
|
if(convertedInput) {
|
|
if( actualType == kFloat )
|
|
valid = validate_float_results( convertedInput, actualResults, width, height, 1, get_channel_order_channel_count(clFormat.image_channel_order) );
|
|
else
|
|
valid = validate_integer_results( convertedInput, actualResults, width, height, 1, get_explicit_type_size( actualType ) );
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
int test_renderbuffer_read( cl_device_id device, cl_context context, cl_command_queue queue, int numElements )
|
|
{
|
|
GLenum attachments[] = { GL_COLOR_ATTACHMENT0_EXT };
|
|
|
|
struct {
|
|
GLenum internal;
|
|
GLenum format;
|
|
GLenum datatype;
|
|
ExplicitType type;
|
|
|
|
} formats[] = {
|
|
{ GL_RGBA, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, kUChar },
|
|
{ GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, kUChar },
|
|
{ GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, kUChar },
|
|
{ GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT, kUShort },
|
|
|
|
// Renderbuffers with integer formats do not seem to work reliably across
|
|
// platforms/implementations. Disabling this in version 1.0 of CL conformance tests.
|
|
|
|
#ifdef TEST_INTEGER_FORMATS
|
|
|
|
{ GL_RGBA8I_EXT, GL_RGBA_INTEGER_EXT, GL_BYTE, kChar },
|
|
{ GL_RGBA16I_EXT, GL_RGBA_INTEGER_EXT, GL_SHORT, kShort },
|
|
{ GL_RGBA32I_EXT, GL_RGBA_INTEGER_EXT, GL_INT, kInt },
|
|
{ GL_RGBA8UI_EXT, GL_RGBA_INTEGER_EXT, GL_UNSIGNED_BYTE, kUChar },
|
|
{ GL_RGBA16UI_EXT, GL_RGBA_INTEGER_EXT, GL_UNSIGNED_SHORT, kUShort },
|
|
{ GL_RGBA32UI_EXT, GL_RGBA_INTEGER_EXT, GL_UNSIGNED_INT, kUInt },
|
|
#endif
|
|
{ GL_RGBA32F_ARB, GL_RGBA, GL_FLOAT, kFloat },
|
|
{ GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT, kHalf }
|
|
};
|
|
|
|
size_t fmtIdx, attIdx;
|
|
int error = 0;
|
|
#ifdef DEBUG
|
|
size_t iter = 1;
|
|
#else
|
|
size_t iter = 6;
|
|
#endif
|
|
RandomSeed seed( gRandomSeed );
|
|
|
|
// Check if images are supported
|
|
if (checkForImageSupport(device)) {
|
|
log_info("Device does not support images. Skipping test.\n");
|
|
return 0;
|
|
}
|
|
|
|
if( !gluCheckExtension( (const GLubyte *)"GL_EXT_framebuffer_object", glGetString( GL_EXTENSIONS ) ) )
|
|
{
|
|
log_info( "Renderbuffers are not supported by this OpenGL implementation; skipping test\n" );
|
|
return 0;
|
|
}
|
|
|
|
// Loop through a set of GL formats, testing a set of sizes against each one
|
|
for( fmtIdx = 0; fmtIdx < sizeof( formats ) / sizeof( formats[ 0 ] ); fmtIdx++ )
|
|
{
|
|
for( attIdx = 0; attIdx < sizeof( attachments ) / sizeof( attachments[ 0 ] ); attIdx++ )
|
|
{
|
|
size_t i;
|
|
|
|
log_info( "Testing renderbuffer read for %s : %s : %s : %s\n",
|
|
GetGLAttachmentName( attachments[ attIdx ] ),
|
|
GetGLFormatName( formats[ fmtIdx ].internal ),
|
|
GetGLBaseFormatName( formats[ fmtIdx ].format ),
|
|
GetGLTypeName( formats[ fmtIdx ].datatype ) );
|
|
|
|
for( i = 0; i < iter; i++ )
|
|
{
|
|
GLsizei width = random_in_range( 16, 512, seed );
|
|
GLsizei height = random_in_range( 16, 512, seed );
|
|
#ifdef DEBUG
|
|
width = height = 4;
|
|
#endif
|
|
|
|
if( test_renderbuffer_read_image( context, queue, width, height,
|
|
attachments[ attIdx ],
|
|
formats[ fmtIdx ].format,
|
|
formats[ fmtIdx ].internal,
|
|
formats[ fmtIdx ].datatype,
|
|
formats[ fmtIdx ].type, seed ) )
|
|
|
|
{
|
|
log_error( "ERROR: Renderbuffer read test failed for %s : %s : %s : %s\n\n",
|
|
GetGLAttachmentName( attachments[ attIdx ] ),
|
|
GetGLFormatName( formats[ fmtIdx ].internal ),
|
|
GetGLBaseFormatName( formats[ fmtIdx ].format ),
|
|
GetGLTypeName( formats[ fmtIdx ].datatype ) );
|
|
|
|
error++;
|
|
break; // Skip other sizes for this combination
|
|
}
|
|
}
|
|
if( i == iter )
|
|
{
|
|
log_info( "passed: Renderbuffer read test passed for %s : %s : %s : %s\n\n",
|
|
GetGLAttachmentName( attachments[ attIdx ] ),
|
|
GetGLFormatName( formats[ fmtIdx ].internal ),
|
|
GetGLBaseFormatName( formats[ fmtIdx ].format ),
|
|
GetGLTypeName( formats[ fmtIdx ].datatype ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
|
|
#pragma mark -------------------- Write tests -------------------------
|
|
|
|
int test_attach_renderbuffer_write_to_image( cl_context context, cl_command_queue queue, GLenum glTarget, GLuint glRenderbuffer,
|
|
size_t imageWidth, size_t imageHeight, cl_image_format *outFormat, ExplicitType *outType, MTdata d, void **outSourceBuffer, bool supports_half )
|
|
{
|
|
int error;
|
|
|
|
// Create a CL image from the supplied GL renderbuffer
|
|
clMemWrapper image = (*clCreateFromGLRenderbuffer_ptr)( context, CL_MEM_WRITE_ONLY, glRenderbuffer, &error );
|
|
if( error != CL_SUCCESS )
|
|
{
|
|
print_error( error, "Unable to create CL image from GL renderbuffer" );
|
|
return error;
|
|
}
|
|
|
|
return test_cl_image_write( context, queue, glTarget, image, imageWidth,
|
|
imageHeight, 1, outFormat, outType, outSourceBuffer, d, supports_half );
|
|
}
|
|
|
|
int test_renderbuffer_image_write( cl_context context, cl_command_queue queue,
|
|
GLsizei width, GLsizei height, GLenum attachment,
|
|
GLenum format, GLenum internalFormat,
|
|
GLenum glType, ExplicitType type, MTdata d )
|
|
{
|
|
int error;
|
|
|
|
if( type == kHalf )
|
|
if( DetectFloatToHalfRoundingMode(queue) )
|
|
return 1;
|
|
|
|
// Create the GL renderbuffer
|
|
glFramebufferWrapper glFramebuffer;
|
|
glRenderbufferWrapper glRenderbuffer;
|
|
CreateGLRenderbuffer( width, height, attachment, format, internalFormat, glType, type, &glFramebuffer, &glRenderbuffer, &error, d, false );
|
|
if( error != 0 )
|
|
{
|
|
if ((format == GL_RGBA_INTEGER_EXT) && (!CheckGLIntegerExtensionSupport()))
|
|
{
|
|
log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. Skipping test.\n");
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return error;
|
|
}
|
|
}
|
|
|
|
// Run and get the results
|
|
cl_image_format clFormat;
|
|
ExplicitType sourceType;
|
|
ExplicitType validationType;
|
|
void *outSourceBuffer;
|
|
|
|
bool supports_half = false;
|
|
error = supportsHalf(context, &supports_half);
|
|
if( error != 0 )
|
|
return error;
|
|
|
|
error = test_attach_renderbuffer_write_to_image( context, queue, attachment, glRenderbuffer, width, height, &clFormat, &sourceType, d, (void **)&outSourceBuffer, supports_half );
|
|
if( error != 0 || ((sourceType == kHalf ) && !supports_half))
|
|
return error;
|
|
|
|
// If actual source type was half, convert to float for validation.
|
|
if( sourceType == kHalf )
|
|
validationType = kFloat;
|
|
else
|
|
validationType = sourceType;
|
|
|
|
BufferOwningPtr<char> validationSource( convert_to_expected( outSourceBuffer, width * height, sourceType, validationType, get_channel_order_channel_count(clFormat.image_channel_order) ) );
|
|
|
|
log_info( "- Write [%4d x %4d] : GL Renderbuffer : %s : %s : %s => CL Image : %s : %s \n", width, height,
|
|
GetGLFormatName( format ), GetGLFormatName( internalFormat ), GetGLTypeName( glType),
|
|
GetChannelOrderName( clFormat.image_channel_order ), GetChannelTypeName( clFormat.image_channel_data_type ));
|
|
|
|
// Now read the results from the GL renderbuffer
|
|
BufferOwningPtr<char> resultData( ReadGLRenderbuffer( glFramebuffer, glRenderbuffer, attachment, format, internalFormat, glType, type, width, height ) );
|
|
|
|
#ifdef DEBUG
|
|
log_info("- start result data -- \n");
|
|
DumpGLBuffer(glType, width, height, resultData);
|
|
log_info("- end result data -- \n");
|
|
#endif
|
|
|
|
// We have to convert our input buffer to the returned type, so we can validate.
|
|
BufferOwningPtr<char> convertedData( convert_to_expected( resultData, width * height, type, validationType, get_channel_order_channel_count(clFormat.image_channel_order) ) );
|
|
|
|
#ifdef DEBUG
|
|
log_info("- start input data -- \n");
|
|
DumpGLBuffer(GetGLTypeForExplicitType(validationType), width, height, validationSource);
|
|
log_info("- end input data -- \n");
|
|
#endif
|
|
|
|
#ifdef DEBUG
|
|
log_info("- start converted data -- \n");
|
|
DumpGLBuffer(GetGLTypeForExplicitType(validationType), width, height, convertedData);
|
|
log_info("- end converted data -- \n");
|
|
#endif
|
|
|
|
// Now we validate
|
|
int valid = 0;
|
|
if(convertedData) {
|
|
if( sourceType == kFloat || sourceType == kHalf )
|
|
valid = validate_float_results( validationSource, convertedData, width, height, 1, get_channel_order_channel_count(clFormat.image_channel_order) );
|
|
else
|
|
valid = validate_integer_results( validationSource, convertedData, width, height, 1, get_explicit_type_size( type ) );
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
int test_renderbuffer_write( cl_device_id device, cl_context context, cl_command_queue queue, int numElements )
|
|
{
|
|
GLenum attachments[] = { GL_COLOR_ATTACHMENT0_EXT };
|
|
|
|
struct {
|
|
GLenum internal;
|
|
GLenum format;
|
|
GLenum datatype;
|
|
ExplicitType type;
|
|
|
|
} formats[] = {
|
|
{ GL_RGBA, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, kUChar },
|
|
{ GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, kUChar },
|
|
{ GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, kUChar },
|
|
{ GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT, kUShort },
|
|
|
|
// Renderbuffers with integer formats do not seem to work reliably across
|
|
// platforms/implementations. Disabling this in version 1.0 of CL conformance tests.
|
|
|
|
#ifdef TEST_INTEGER_FORMATS
|
|
|
|
{ GL_RGBA8I_EXT, GL_RGBA_INTEGER_EXT, GL_BYTE, kChar },
|
|
{ GL_RGBA16I_EXT, GL_RGBA_INTEGER_EXT, GL_SHORT, kShort },
|
|
{ GL_RGBA32I_EXT, GL_RGBA_INTEGER_EXT, GL_INT, kInt },
|
|
{ GL_RGBA8UI_EXT, GL_RGBA_INTEGER_EXT, GL_UNSIGNED_BYTE, kUChar },
|
|
{ GL_RGBA16UI_EXT, GL_RGBA_INTEGER_EXT, GL_UNSIGNED_SHORT, kUShort },
|
|
{ GL_RGBA32UI_EXT, GL_RGBA_INTEGER_EXT, GL_UNSIGNED_INT, kUInt },
|
|
#endif
|
|
{ GL_RGBA32F_ARB, GL_RGBA, GL_FLOAT, kFloat },
|
|
{ GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT, kHalf }
|
|
};
|
|
|
|
size_t fmtIdx, attIdx;
|
|
int error = 0;
|
|
size_t iter = 6;
|
|
#ifdef DEBUG
|
|
iter = 1;
|
|
#endif
|
|
RandomSeed seed( gRandomSeed );
|
|
|
|
// Check if images are supported
|
|
if (checkForImageSupport(device)) {
|
|
log_info("Device does not support images. Skipping test.\n");
|
|
return 0;
|
|
}
|
|
|
|
if( !gluCheckExtension( (const GLubyte *)"GL_EXT_framebuffer_object", glGetString( GL_EXTENSIONS ) ) )
|
|
{
|
|
log_info( "Renderbuffers are not supported by this OpenGL implementation; skipping test\n" );
|
|
return 0;
|
|
}
|
|
|
|
// Loop through a set of GL formats, testing a set of sizes against each one
|
|
for( fmtIdx = 0; fmtIdx < sizeof( formats ) / sizeof( formats[ 0 ] ); fmtIdx++ )
|
|
{
|
|
for( attIdx = 0; attIdx < sizeof( attachments ) / sizeof( attachments[ 0 ] ); attIdx++ )
|
|
{
|
|
log_info( "Testing Renderbuffer write test for %s : %s : %s : %s\n",
|
|
GetGLAttachmentName( attachments[ attIdx ] ),
|
|
GetGLFormatName( formats[ fmtIdx ].internal ),
|
|
GetGLBaseFormatName( formats[ fmtIdx ].format ),
|
|
GetGLTypeName( formats[ fmtIdx ].datatype ) );
|
|
|
|
size_t i;
|
|
for( i = 0; i < iter; i++ )
|
|
{
|
|
GLsizei width = random_in_range( 16, 512, seed );
|
|
GLsizei height = random_in_range( 16, 512, seed );
|
|
#ifdef DEBUG
|
|
width = height = 4;
|
|
#endif
|
|
|
|
if( test_renderbuffer_image_write( context, queue, width, height,
|
|
attachments[ attIdx ],
|
|
formats[ fmtIdx ].format,
|
|
formats[ fmtIdx ].internal,
|
|
formats[ fmtIdx ].datatype,
|
|
formats[ fmtIdx ].type, seed ) )
|
|
{
|
|
log_error( "ERROR: Renderbuffer write test failed for %s : %s : %s : %s\n\n",
|
|
GetGLAttachmentName( attachments[ attIdx ] ),
|
|
GetGLFormatName( formats[ fmtIdx ].internal ),
|
|
GetGLBaseFormatName( formats[ fmtIdx ].format ),
|
|
GetGLTypeName( formats[ fmtIdx ].datatype ) );
|
|
|
|
error++;
|
|
break; // Skip other sizes for this combination
|
|
}
|
|
}
|
|
if( i == iter )
|
|
{
|
|
log_info( "passed: Renderbuffer write test passed for %s : %s : %s : %s\n\n",
|
|
GetGLAttachmentName( attachments[ attIdx ] ),
|
|
GetGLFormatName( formats[ fmtIdx ].internal ),
|
|
GetGLBaseFormatName( formats[ fmtIdx ].format ),
|
|
GetGLTypeName( formats[ fmtIdx ].datatype ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|