test_conformance/gl/test_images_getinfo_common.cpp - external/github.com/KhronosGroup/OpenCL-CTS - Git at Google

 //
 // 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"
 #include "common.h"

 #if defined( __APPLE__ )
     #include <OpenGL/glu.h>
 #else
     #include <GL/glu.h>
     #include <CL/cl_gl.h>
 #endif

 extern int supportsHalf(cl_context context, bool* supports_half);

 static int test_image_info( cl_context context, cl_command_queue queue,
   GLenum glTarget, GLuint glTexture, size_t imageWidth, size_t imageHeight,
   size_t imageDepth, cl_image_format *outFormat, ExplicitType *outType,
   void **outResultBuffer )
 {
   clMemWrapper streams[ 2 ];

   int error;

   // Create a CL image from the supplied GL texture
   streams[ 0 ] = (*clCreateFromGLTexture_ptr)( context, CL_MEM_READ_ONLY,
     glTarget, 0, glTexture, &error );
   if( error != CL_SUCCESS )
   {
     print_error( error, "Unable to create CL image from GL texture" );
     GLint fmt;
     glGetTexLevelParameteriv( glTarget, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt );
     log_error( "    Supplied GL texture was format %s\n", GetGLFormatName( fmt ) );
     return error;
   }

   // Determine data type and format that CL came up with
   error = clGetImageInfo( streams[ 0 ], CL_IMAGE_FORMAT,
     sizeof( cl_image_format ), outFormat, NULL );
   test_error( error, "Unable to get CL image format" );

   cl_gl_object_type object_type;
   switch (glTarget) {
     case GL_TEXTURE_1D:
       object_type = CL_GL_OBJECT_TEXTURE1D;
       break;
     case GL_TEXTURE_BUFFER:
       object_type = CL_GL_OBJECT_TEXTURE_BUFFER;
       break;
     case GL_TEXTURE_1D_ARRAY:
       object_type = CL_GL_OBJECT_TEXTURE1D_ARRAY;
       break;
     case GL_TEXTURE_2D:
     case GL_TEXTURE_RECTANGLE_EXT:
     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:
       object_type = CL_GL_OBJECT_TEXTURE2D;
       break;
     case GL_TEXTURE_2D_ARRAY:
       object_type = CL_GL_OBJECT_TEXTURE2D_ARRAY;
       break;
     case GL_TEXTURE_3D:
       object_type = CL_GL_OBJECT_TEXTURE3D;
       break;
     default:
       log_error("Unsupported texture target.");
       return 1;
   }

   return CheckGLObjectInfo(streams[0], object_type, glTexture, glTarget, 0);
 }

 static int test_image_format_get_info(
     cl_context context, cl_command_queue queue,
     size_t width, size_t height, size_t depth,
     GLenum target, struct format* fmt, MTdata data)
 {
   int error = 0;

   // If we're testing a half float format, then we need to determine the
   // rounding mode of this machine.  Punt if we fail to do so.

   if( fmt->type == kHalf )
   {
     if( DetectFloatToHalfRoundingMode(queue) )
       return 0;
     bool supports_half = false;
     error = supportsHalf(context, &supports_half);
     if( error != 0 )
       return error;
     if (!supports_half) return 0;
   }

   size_t w = width, h = height, d = depth;

   // Unpack the format and use it, along with the target, to create an
   // appropriate GL texture.

   GLenum gl_fmt          = fmt->formattype;
   GLenum gl_internal_fmt = fmt->internal;
   GLenum gl_type         = fmt->datatype;
   ExplicitType type      = fmt->type;

   glTextureWrapper texture;
   glBufferWrapper glbuf;

   // If we're testing a half float format, then we need to determine the
   // rounding mode of this machine.  Punt if we fail to do so.

   if( fmt->type == kHalf )
     if( DetectFloatToHalfRoundingMode(queue) )
       return 1;

   // Use the correct texture creation function depending on the target, and
   // adjust width, height, depth as appropriate so subsequent size calculations
   // succeed.

   switch (target) {
     case GL_TEXTURE_1D:
       h = 1; d = 1;
       CreateGLTexture1D( width, target, gl_fmt,
         gl_internal_fmt, gl_type, type, &texture, &error, false, data );
       break;
     case GL_TEXTURE_BUFFER:
       h = 1; d = 1;
       CreateGLTextureBuffer( width, target, gl_fmt,
         gl_internal_fmt, gl_type, type, &texture, &glbuf, &error, false, data );
       break;
     case GL_TEXTURE_1D_ARRAY:
       d = 1;
       CreateGLTexture1DArray( width, height, target, gl_fmt,
         gl_internal_fmt, gl_type, type, &texture, &error, false, data );
       break;
     case GL_TEXTURE_RECTANGLE_EXT:
     case GL_TEXTURE_2D:
     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:
       d = 1;
       CreateGLTexture2D( width, height, target, gl_fmt,
         gl_internal_fmt, gl_type, type, &texture, &error, false, data );
       break;
     case GL_TEXTURE_2D_ARRAY:
       CreateGLTexture2DArray( width, height, depth, target, gl_fmt,
         gl_internal_fmt, gl_type, type, &texture, &error, false, data );
       break;
     case GL_TEXTURE_3D:
       d = 1;
       CreateGLTexture3D( width, height, depth, target, gl_fmt,
         gl_internal_fmt, gl_type, type, &texture, &error, data, false );
       break;
     default:
       log_error("Unsupported texture target.\n");
       return 1;
   }

   if ( error == -2 ) {
     log_info("OpenGL texture couldn't be created, because a texture is too big. Skipping test.\n");
     return 0;
   }

   if ( error != 0 ) {
     if ((gl_fmt == GL_RGBA_INTEGER_EXT) && (!CheckGLIntegerExtensionSupport())) {
       log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. "
         "Skipping test.\n");
       return 0;
     } else {
       return error;
     }
   }

   cl_image_format clFormat;
   ExplicitType actualType;
   char *outBuffer;

   // Perform the info check:
   return test_image_info( context, queue, target, texture, w, h, d, &clFormat,
     &actualType, (void **)&outBuffer );
 }

 int test_images_get_info_common( cl_device_id device, cl_context context,
   cl_command_queue queue, struct format* formats, size_t nformats,
   GLenum *targets, size_t ntargets, sizevec_t *sizes, size_t nsizes )
 {
   int error = 0;
   RandomSeed seed(gRandomSeed);

   // First, ensure this device supports images.

   if (checkForImageSupport(device)) {
     log_info("Device does not support images.  Skipping test.\n");
     return 0;
   }

   size_t fidx, tidx, sidx;

   // Test each format on every target, every size.

   for ( fidx = 0; fidx < nformats; fidx++ ) {
     for ( tidx = 0; tidx < ntargets; tidx++ ) {

       if ( formats[ fidx ].datatype == GL_UNSIGNED_INT_2_10_10_10_REV )
       {
         // Check if the RGB 101010 format is supported
         if ( is_rgb_101010_supported( context, targets[ tidx ] ) == 0 )
           break; // skip
       }

       log_info( "Testing image info for GL format %s : %s : %s : %s\n",
         GetGLTargetName( targets[ tidx ] ),
         GetGLFormatName( formats[ fidx ].internal ),
         GetGLBaseFormatName( formats[ fidx ].formattype ),
         GetGLTypeName( formats[ fidx ].datatype ) );

       for ( sidx = 0; sidx < nsizes; sidx++ ) {

         // Test this format + size:

         if ( test_image_format_get_info(context, queue,
                                         sizes[sidx].width, sizes[sidx].height, sizes[sidx].depth,
                                         targets[tidx], &formats[fidx], seed) )
         {
           // We land here in the event of test failure.

           log_error( "ERROR: Image info test failed for %s : %s : %s : %s\n\n",
             GetGLTargetName( targets[ tidx ] ),
             GetGLFormatName( formats[ fidx ].internal ),
             GetGLBaseFormatName( formats[ fidx ].formattype ),
             GetGLTypeName( formats[ fidx ].datatype ) );
           error++;

           // Skip the other sizes for this format.

           break;
         }
       }
     }
   }

   return error;
 }
	//
	// 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"
	#include "common.h"

	#if defined( __APPLE__ )
	#include <OpenGL/glu.h>
	#else
	#include <GL/glu.h>
	#include <CL/cl_gl.h>
	#endif

	extern int supportsHalf(cl_context context, bool* supports_half);

	static int test_image_info( cl_context context, cl_command_queue queue,
	GLenum glTarget, GLuint glTexture, size_t imageWidth, size_t imageHeight,
	size_t imageDepth, cl_image_format outFormat, ExplicitType outType,
	void **outResultBuffer )
	{
	clMemWrapper streams[ 2 ];

	int error;

	// Create a CL image from the supplied GL texture
	streams[ 0 ] = (*clCreateFromGLTexture_ptr)( context, CL_MEM_READ_ONLY,
	glTarget, 0, glTexture, &error );
	if( error != CL_SUCCESS )
	{
	print_error( error, "Unable to create CL image from GL texture" );
	GLint fmt;
	glGetTexLevelParameteriv( glTarget, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt );
	log_error( " Supplied GL texture was format %s\n", GetGLFormatName( fmt ) );
	return error;
	}

	// Determine data type and format that CL came up with
	error = clGetImageInfo( streams[ 0 ], CL_IMAGE_FORMAT,
	sizeof( cl_image_format ), outFormat, NULL );
	test_error( error, "Unable to get CL image format" );

	cl_gl_object_type object_type;
	switch (glTarget) {
	case GL_TEXTURE_1D:
	object_type = CL_GL_OBJECT_TEXTURE1D;
	break;
	case GL_TEXTURE_BUFFER:
	object_type = CL_GL_OBJECT_TEXTURE_BUFFER;
	break;
	case GL_TEXTURE_1D_ARRAY:
	object_type = CL_GL_OBJECT_TEXTURE1D_ARRAY;
	break;
	case GL_TEXTURE_2D:
	case GL_TEXTURE_RECTANGLE_EXT:
	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:
	object_type = CL_GL_OBJECT_TEXTURE2D;
	break;
	case GL_TEXTURE_2D_ARRAY:
	object_type = CL_GL_OBJECT_TEXTURE2D_ARRAY;
	break;
	case GL_TEXTURE_3D:
	object_type = CL_GL_OBJECT_TEXTURE3D;
	break;
	default:
	log_error("Unsupported texture target.");
	return 1;
	}

	return CheckGLObjectInfo(streams[0], object_type, glTexture, glTarget, 0);
	}

	static int test_image_format_get_info(
	cl_context context, cl_command_queue queue,
	size_t width, size_t height, size_t depth,
	GLenum target, struct format* fmt, MTdata data)
	{
	int error = 0;

	// If we're testing a half float format, then we need to determine the
	// rounding mode of this machine. Punt if we fail to do so.

	if( fmt->type == kHalf )
	{
	if( DetectFloatToHalfRoundingMode(queue) )
	return 0;
	bool supports_half = false;
	error = supportsHalf(context, &supports_half);
	if( error != 0 )
	return error;
	if (!supports_half) return 0;
	}

	size_t w = width, h = height, d = depth;

	// Unpack the format and use it, along with the target, to create an
	// appropriate GL texture.

	GLenum gl_fmt = fmt->formattype;
	GLenum gl_internal_fmt = fmt->internal;
	GLenum gl_type = fmt->datatype;
	ExplicitType type = fmt->type;

	glTextureWrapper texture;
	glBufferWrapper glbuf;

	// If we're testing a half float format, then we need to determine the
	// rounding mode of this machine. Punt if we fail to do so.

	if( fmt->type == kHalf )
	if( DetectFloatToHalfRoundingMode(queue) )
	return 1;

	// Use the correct texture creation function depending on the target, and
	// adjust width, height, depth as appropriate so subsequent size calculations
	// succeed.

	switch (target) {
	case GL_TEXTURE_1D:
	h = 1; d = 1;
	CreateGLTexture1D( width, target, gl_fmt,
	gl_internal_fmt, gl_type, type, &texture, &error, false, data );
	break;
	case GL_TEXTURE_BUFFER:
	h = 1; d = 1;
	CreateGLTextureBuffer( width, target, gl_fmt,
	gl_internal_fmt, gl_type, type, &texture, &glbuf, &error, false, data );
	break;
	case GL_TEXTURE_1D_ARRAY:
	d = 1;
	CreateGLTexture1DArray( width, height, target, gl_fmt,
	gl_internal_fmt, gl_type, type, &texture, &error, false, data );
	break;
	case GL_TEXTURE_RECTANGLE_EXT:
	case GL_TEXTURE_2D:
	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:
	d = 1;
	CreateGLTexture2D( width, height, target, gl_fmt,
	gl_internal_fmt, gl_type, type, &texture, &error, false, data );
	break;
	case GL_TEXTURE_2D_ARRAY:
	CreateGLTexture2DArray( width, height, depth, target, gl_fmt,
	gl_internal_fmt, gl_type, type, &texture, &error, false, data );
	break;
	case GL_TEXTURE_3D:
	d = 1;
	CreateGLTexture3D( width, height, depth, target, gl_fmt,
	gl_internal_fmt, gl_type, type, &texture, &error, data, false );
	break;
	default:
	log_error("Unsupported texture target.\n");
	return 1;
	}

	if ( error == -2 ) {
	log_info("OpenGL texture couldn't be created, because a texture is too big. Skipping test.\n");
	return 0;
	}

	if ( error != 0 ) {
	if ((gl_fmt == GL_RGBA_INTEGER_EXT) && (!CheckGLIntegerExtensionSupport())) {
	log_info("OpenGL version does not support GL_RGBA_INTEGER_EXT. "
	"Skipping test.\n");
	return 0;
	} else {
	return error;
	}
	}

	cl_image_format clFormat;
	ExplicitType actualType;
	char *outBuffer;

	// Perform the info check:
	return test_image_info( context, queue, target, texture, w, h, d, &clFormat,
	&actualType, (void **)&outBuffer );
	}

	int test_images_get_info_common( cl_device_id device, cl_context context,
	cl_command_queue queue, struct format* formats, size_t nformats,
	GLenum targets, size_t ntargets, sizevec_t sizes, size_t nsizes )
	{
	int error = 0;
	RandomSeed seed(gRandomSeed);

	// First, ensure this device supports images.

	if (checkForImageSupport(device)) {
	log_info("Device does not support images. Skipping test.\n");
	return 0;
	}

	size_t fidx, tidx, sidx;

	// Test each format on every target, every size.

	for ( fidx = 0; fidx < nformats; fidx++ ) {
	for ( tidx = 0; tidx < ntargets; tidx++ ) {

	if ( formats[ fidx ].datatype == GL_UNSIGNED_INT_2_10_10_10_REV )
	{
	// Check if the RGB 101010 format is supported
	if ( is_rgb_101010_supported( context, targets[ tidx ] ) == 0 )
	break; // skip
	}

	log_info( "Testing image info for GL format %s : %s : %s : %s\n",
	GetGLTargetName( targets[ tidx ] ),
	GetGLFormatName( formats[ fidx ].internal ),
	GetGLBaseFormatName( formats[ fidx ].formattype ),
	GetGLTypeName( formats[ fidx ].datatype ) );

	for ( sidx = 0; sidx < nsizes; sidx++ ) {

	// Test this format + size:

	if ( test_image_format_get_info(context, queue,
	sizes[sidx].width, sizes[sidx].height, sizes[sidx].depth,
	targets[tidx], &formats[fidx], seed) )
	{
	// We land here in the event of test failure.

	log_error( "ERROR: Image info test failed for %s : %s : %s : %s\n\n",
	GetGLTargetName( targets[ tidx ] ),
	GetGLFormatName( formats[ fidx ].internal ),
	GetGLBaseFormatName( formats[ fidx ].formattype ),
	GetGLTypeName( formats[ fidx ].datatype ) );
	error++;

	// Skip the other sizes for this format.

	break;
	}
	}
	}
	}

	return error;
	}