ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 14:09:03 +00:00
Code Packages Projects Releases Wiki Activity

[NFC] clang-format gl (#1612)

Browse Source 
Add some clang-format off/on comments to keep kernel code readable.

Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
This commit is contained in:
Sven van Haastregt
2023-02-06 15:09:04 +00:00
committed by GitHub
parent 2318cedb21
commit f46cca0f8f
19 changed files with 3497 additions and 3027 deletions
Download Patch File Download Diff File Expand all files Collapse all files

485
test_conformance/gl/test_renderbuffer.cpp
View File

@@ -1,6 +1,6 @@
//
// 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
@@ -15,93 +15,102 @@
//
#include "testBase.h"
#if defined( __APPLE__ )
#include <OpenGL/glu.h>
#if defined(__APPLE__)
#include <OpenGL/glu.h>
#else
#include <GL/glu.h>
#include <CL/cl_gl.h>
#include <GL/glu.h>
#include <CL/cl_gl.h>
#endif
#if defined (__linux__)
GLboolean
gluCheckExtension(const GLubyte *extension, const GLubyte *extensions)
#if defined(__linux__)
GLboolean gluCheckExtension(const GLubyte *extension, const GLubyte *extensions)
{
const GLubyte *start;
GLubyte *where, *terminator;
const GLubyte *start;
GLubyte *where, *terminator;
/* Extension names should not have spaces. */
where = (GLubyte *) strchr((const char*)extension, ' ');
if (where || *extension == '\0')
/* 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;
/* 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_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 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);
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 )
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 )
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" );
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 );
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 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;
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 );
void *tmp = CreateGLRenderbuffer(
width, height, attachment, format, internalFormat, glType, type,
&glFramebuffer, &glRenderbuffer, &error, d, true);
BufferOwningPtr<char> inputBuffer(tmp);
if( error != 0 )
if (error != 0)
{
if ((format == GL_RGBA_INTEGER_EXT) && (!CheckGLIntegerExtensionSupport()))
if ((format == GL_RGBA_INTEGER_EXT)
&& (!CheckGLIntegerExtensionSupport()))
{
log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. Skipping test.\n");
log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. "
"Skipping test.\n");
return 0;
}
else
@@ -114,14 +123,18 @@ int test_renderbuffer_read_image( cl_context context, cl_command_queue queue,
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;
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 ));
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");
@@ -129,63 +142,76 @@ int test_renderbuffer_read_image( cl_context context, cl_command_queue queue,
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) ));
// 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);
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);
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) );
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 ) );
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 )
int test_renderbuffer_read(cl_device_id device, cl_context context,
cl_command_queue queue, int numElements)
{
GLenum attachments[] = { GL_COLOR_ATTACHMENT0_EXT };
struct {
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 },
{ 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.
// 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 },
{ 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 }
{ GL_RGBA32F_ARB, GL_RGBA, GL_FLOAT, kFloat },
{ GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT, kHalf }
};
size_t fmtIdx, attIdx;
@@ -195,66 +221,70 @@ int test_renderbuffer_read( cl_device_id device, cl_context context, cl_command_
#else
size_t iter = 6;
#endif
RandomSeed seed( gRandomSeed );
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 ) ) )
// Check if images are supported
if (checkForImageSupport(device))
{
log_info( "Renderbuffers are not supported by this OpenGL implementation; skipping test\n" );
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 (fmtIdx = 0; fmtIdx < sizeof(formats) / sizeof(formats[0]); fmtIdx++)
{
for( attIdx = 0; attIdx < sizeof( attachments ) / sizeof( attachments[ 0 ] ); attIdx++ )
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 ) );
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++ )
for (i = 0; i < iter; i++)
{
GLsizei width = random_in_range( 16, 512, seed );
GLsizei height = random_in_range( 16, 512, seed );
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 ) )
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 ) );
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
break; // Skip other sizes for this combination
}
}
if( i == iter )
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 ) );
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));
}
}
}
@@ -265,43 +295,52 @@ int test_renderbuffer_read( cl_device_id device, cl_context context, cl_command_
#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 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 )
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" );
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 );
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 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;
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 )
CreateGLRenderbuffer(width, height, attachment, format, internalFormat,
glType, type, &glFramebuffer, &glRenderbuffer, &error,
d, false);
if (error != 0)
{
if ((format == GL_RGBA_INTEGER_EXT) && (!CheckGLIntegerExtensionSupport()))
if ((format == GL_RGBA_INTEGER_EXT)
&& (!CheckGLIntegerExtensionSupport()))
{
log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. Skipping test.\n");
log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. "
"Skipping test.\n");
return 0;
}
else
@@ -318,27 +357,34 @@ int test_renderbuffer_image_write( cl_context context, cl_command_queue queue,
bool supports_half = false;
error = supportsHalf(context, &supports_half);
if( error != 0 )
return error;
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;
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 )
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) ) );
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 ));
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 ) );
BufferOwningPtr<char> resultData(
ReadGLRenderbuffer(glFramebuffer, glRenderbuffer, attachment, format,
internalFormat, glType, type, width, height));
#ifdef DEBUG
log_info("- start result data -- \n");
@@ -346,63 +392,76 @@ int test_renderbuffer_image_write( cl_context context, cl_command_queue queue,
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) ) );
// 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);
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);
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) );
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 ) );
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 )
int test_renderbuffer_write(cl_device_id device, cl_context context,
cl_command_queue queue, int numElements)
{
GLenum attachments[] = { GL_COLOR_ATTACHMENT0_EXT };
struct {
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 },
{ 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.
// 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 },
{ 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 }
{ GL_RGBA32F_ARB, GL_RGBA, GL_FLOAT, kFloat },
{ GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT, kHalf }
};
size_t fmtIdx, attIdx;
@@ -411,64 +470,68 @@ int test_renderbuffer_write( cl_device_id device, cl_context context, cl_command
#ifdef DEBUG
iter = 1;
#endif
RandomSeed seed( gRandomSeed );
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 ) ) )
// Check if images are supported
if (checkForImageSupport(device))
{
log_info( "Renderbuffers are not supported by this OpenGL implementation; skipping test\n" );
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 (fmtIdx = 0; fmtIdx < sizeof(formats) / sizeof(formats[0]); fmtIdx++)
{
for( attIdx = 0; attIdx < sizeof( attachments ) / sizeof( attachments[ 0 ] ); attIdx++ )
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 ) );
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++ )
for (i = 0; i < iter; i++)
{
GLsizei width = random_in_range( 16, 512, seed );
GLsizei height = random_in_range( 16, 512, seed );
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 ) )
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 ) );
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
break; // Skip other sizes for this combination
}
}
if( i == iter )
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 ) );
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));
}
}
}