Raw10/12 CTS tests

test_common/harness/errorHelpers.cpp

@@ -202,6 +202,8 @@ const char *GetChannelTypeName(cl_channel_type type)
         case CL_SFIXED14_APPLE: return "CL_SFIXED14_APPLE";
 #endif
         case CL_UNORM_INT24: return "CL_UNORM_INT24";
+        case CL_UNSIGNED_INT_RAW10_EXT: return "CL_UNSIGNED_INT_RAW10_EXT";
+        case CL_UNSIGNED_INT_RAW12_EXT: return "CL_UNSIGNED_INT_RAW12_EXT";
         default: return NULL;
     }
 }

test_common/harness/imageHelpers.cpp

@@ -288,6 +288,9 @@ uint32_t get_pixel_size(const cl_image_format *format)
             return get_format_channel_count(format) * sizeof(cl_float);
         case CL_UNORM_INT_101010_2: return 4;
 
+        case CL_UNSIGNED_INT_RAW10_EXT:
+        case CL_UNSIGNED_INT_RAW12_EXT: return 2;
+
         default: return 0;
     }
 }

test_common/harness/imageHelpers.h

@@ -191,6 +191,42 @@ cl_uint compute_max_mip_levels(size_t width, size_t height, size_t depth);
 cl_ulong compute_mipmapped_image_size(image_descriptor imageInfo);
 size_t compute_mip_level_offset(image_descriptor *imageInfo, size_t lod);
 
+constexpr size_t RAW10_EXT_CLUMP_SIZE = 5;
+constexpr size_t RAW10_EXT_CLUMP_NUM_PIXELS = 4;
+constexpr size_t RAW12_EXT_CLUMP_SIZE = 3;
+constexpr size_t RAW12_EXT_CLUMP_NUM_PIXELS = 2;
+
+inline bool is_width_compatible(image_descriptor imageInfo)
+{
+    if (imageInfo.format->image_channel_data_type == CL_UNSIGNED_INT_RAW10_EXT
+        && (imageInfo.width % RAW10_EXT_CLUMP_NUM_PIXELS) != 0)
+    {
+        return false;
+    }
+    if (imageInfo.format->image_channel_data_type == CL_UNSIGNED_INT_RAW12_EXT
+        && (imageInfo.width % RAW12_EXT_CLUMP_NUM_PIXELS) != 0)
+    {
+        return false;
+    }
+    return true;
+}
+
+inline size_t calculate_row_pitch(image_descriptor imageInfo, size_t pixelSize)
+{
+    if (imageInfo.format->image_channel_data_type == CL_UNSIGNED_INT_RAW10_EXT)
+    {
+        return (imageInfo.width * RAW10_EXT_CLUMP_SIZE)
+            / RAW10_EXT_CLUMP_NUM_PIXELS;
+    }
+    if (imageInfo.format->image_channel_data_type == CL_UNSIGNED_INT_RAW12_EXT)
+    {
+        return (imageInfo.width * RAW12_EXT_CLUMP_SIZE)
+            / RAW12_EXT_CLUMP_NUM_PIXELS;
+    }
+
+    return imageInfo.width * pixelSize;
+}
+
 template <class T>
 void read_image_pixel(void *imageData, image_descriptor *imageInfo, int x,
                       int y, int z, T *outData, int lod)
@@ -255,10 +291,24 @@ void read_image_pixel(void *imageData, image_descriptor *imageInfo, int x,
 
     // Advance to the right spot
     char *ptr = (char *)imageData;
-    size_t pixelSize = get_pixel_size(format);
-
-    ptr += z * slice_pitch_lod + y * row_pitch_lod + x * pixelSize;
-
+    switch (format->image_channel_data_type)
+    {
+        case CL_UNSIGNED_INT_RAW10_EXT: {
+            ptr += z * slice_pitch_lod + y * row_pitch_lod
+                + (x / RAW10_EXT_CLUMP_NUM_PIXELS) * RAW10_EXT_CLUMP_SIZE;
+            break;
+        }
+        case CL_UNSIGNED_INT_RAW12_EXT: {
+            ptr += z * slice_pitch_lod + y * row_pitch_lod
+                + (x / RAW12_EXT_CLUMP_NUM_PIXELS) * RAW12_EXT_CLUMP_SIZE;
+            break;
+        }
+        default: {
+            size_t pixelSize = get_pixel_size(format);
+            ptr += z * slice_pitch_lod + y * row_pitch_lod + x * pixelSize;
+            break;
+        }
+    }
     // OpenCL only supports reading floats from certain formats
     switch (format->image_channel_data_type)
     {
@@ -377,6 +427,26 @@ void read_image_pixel(void *imageData, image_descriptor *imageInfo, int x,
             break;
         }
 #endif
+        case CL_UNSIGNED_INT_RAW10_EXT: {
+            cl_uchar *dPtr = (cl_uchar *)ptr;
+            i = x % RAW10_EXT_CLUMP_NUM_PIXELS;
+            uint8_t bit_index = i << 1;
+            uint16_t hi_val = dPtr[i] << 2;
+            uint16_t lo_val = (dPtr[4] & (0x3 << bit_index)) >> bit_index;
+
+            tempData[0] = (T)(hi_val | lo_val);
+            break;
+        }
+        case CL_UNSIGNED_INT_RAW12_EXT: {
+            cl_uchar *dPtr = (cl_uchar *)ptr;
+            i = x % RAW12_EXT_CLUMP_NUM_PIXELS;
+            uint8_t bit_index = i << 2;
+            uint16_t hi_val = dPtr[i] << 4;
+            uint16_t lo_val = (dPtr[2] & (0xF << bit_index)) >> bit_index;
+
+            tempData[0] = (T)(hi_val | lo_val);
+            break;
+        }
     }
 
 

test_conformance/images/kernel_read_write/CMakeLists.txt

@@ -16,6 +16,7 @@ set(${MODULE_NAME}_SOURCES
     test_write_3D.cpp
     test_cl_ext_image_requirements_info.cpp
     test_cl_ext_image_from_buffer.cpp
+    test_cl_ext_image_raw10_raw12.cpp
     ../common.cpp
 )
 

test_conformance/images/kernel_read_write/main.cpp

@@ -89,6 +89,8 @@ extern int image_from_buffer_fill_positive(cl_device_id device,
 extern int image_from_buffer_read_positive(cl_device_id device,
                                            cl_context context,
                                            cl_command_queue queue);
+extern int ext_image_raw10_raw12(cl_device_id device, cl_context context,
+                                 cl_command_queue queue);
 
 /** read_write images only support sampler-less read buildt-ins which require special settings
   * for some global parameters. This pair of functions temporarily overwrite those global parameters
@@ -367,6 +369,12 @@ int test_image_from_buffer_read_positive(cl_device_id device,
     return image_from_buffer_read_positive(device, context, queue);
 }
 
+int test_cl_ext_image_raw10_raw12(cl_device_id device, cl_context context,
+                                  cl_command_queue queue, int num_elements)
+{
+    return ext_image_raw10_raw12(device, context, queue);
+}
+
 test_definition test_list[] = {
     ADD_TEST(1D),
     ADD_TEST(2D),
@@ -385,6 +393,7 @@ test_definition test_list[] = {
     ADD_TEST_VERSION(image_from_small_buffer_negative, Version(3, 0)),
     ADD_TEST_VERSION(image_from_buffer_fill_positive, Version(3, 0)),
     ADD_TEST_VERSION(image_from_buffer_read_positive, Version(3, 0)),
+    ADD_TEST_VERSION(cl_ext_image_raw10_raw12, Version(1, 2)),
 };
 
 const int test_num = ARRAY_SIZE( test_list );

test_conformance/images/kernel_read_write/test_cl_ext_image_raw10_raw12.cpp

@@ -0,0 +1,78 @@
+//
+// Copyright (c) 2023 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"
+#include "test_cl_ext_image_buffer.hpp"
+
+extern int gTypesToTest;
+extern int gtestTypesToRun;
+extern bool gTestImage2DFromBuffer;
+extern cl_mem_flags gMemFlagsToUse;
+
+static int test_image_set(cl_device_id device, cl_context context,
+                          cl_command_queue queue, cl_mem_object_type imageType)
+{
+    int ret = 0;
+
+    // Grab the list of supported image formats for integer reads
+    std::vector<cl_image_format> formatList = {
+        { CL_R, CL_UNSIGNED_INT_RAW10_EXT }, { CL_R, CL_UNSIGNED_INT_RAW12_EXT }
+    };
+
+    // First time through, we'll go ahead and print the formats supported,
+    // regardless of type
+    log_info("---- Supported %s %s formats for this device for "
+             "cl_ext_image_raw10_raw12---- \n",
+             convert_image_type_to_string(imageType), "read");
+    log_info("  %-7s %-24s %d\n", "CL_R", "CL_UNSIGNED_INT_RAW10_EXT", 0);
+    log_info("  %-7s %-24s %d\n", "CL_R", "CL_UNSIGNED_INT_RAW12_EXT", 0);
+    log_info("------------------------------------------- \n");
+
+    image_sampler_data imageSampler;
+    ImageTestTypes test{ kTestUInt, kUInt, uintFormats, "uint" };
+    if (gTypesToTest & test.type)
+    {
+        std::vector<bool> filterFlags(formatList.size(), false);
+        imageSampler.filter_mode = CL_FILTER_NEAREST;
+        ret = test_read_image_formats(device, context, queue, formatList,
+                                      filterFlags, &imageSampler,
+                                      test.explicitType, imageType);
+    }
+    return ret;
+}
+
+int ext_image_raw10_raw12(cl_device_id device, cl_context context,
+                          cl_command_queue queue)
+{
+    int ret = 0;
+
+    if (0 == is_extension_available(device, "cl_ext_image_raw10_raw12"))
+    {
+        log_info("-----------------------------------------------------\n");
+        log_info("This device does not support "
+                 "cl_ext_image_raw10_raw12.\n");
+        log_info("Skipping cl_ext_image_raw10_raw12 "
+                 "image test.\n");
+        log_info("-----------------------------------------------------\n\n");
+        return 0;
+    }
+    gtestTypesToRun = kReadTests;
+
+    ret += test_image_set(device, context, queue, CL_MEM_OBJECT_IMAGE2D);
+
+    return ret;
+}

test_conformance/images/kernel_read_write/test_iterations.cpp

@@ -1663,7 +1663,9 @@ int test_read_image_set_2D(cl_device_id device, cl_context context,
     {
         for( imageInfo.width = 1; imageInfo.width < 13; imageInfo.width++ )
         {
-            imageInfo.rowPitch = imageInfo.width * pixelSize;
+            if (!is_width_compatible(imageInfo)) continue;
+            imageInfo.rowPitch = calculate_row_pitch(imageInfo, pixelSize);
+
             for( imageInfo.height = 1; imageInfo.height < 9; imageInfo.height++ )
             {
                 if( gTestMipmaps )
@@ -1688,10 +1690,28 @@ int test_read_image_set_2D(cl_device_id device, cl_context context,
 
         for( size_t idx = 0; idx < numbeOfSizes; idx++ )
         {
-            imageInfo.width = sizes[ idx ][ 0 ];
-            imageInfo.height = sizes[ idx ][ 1 ];
-            imageInfo.rowPitch = imageInfo.width * pixelSize;
-            log_info("Testing %d x %d\n", (int)sizes[ idx ][ 0 ], (int)sizes[ idx ][ 1 ]);
+            if (imageInfo.format->image_channel_data_type
+                == CL_UNSIGNED_INT_RAW10_EXT)
+            {
+                imageInfo.width = sizes[idx][0] & ~0x3ULL;
+            }
+            else if (imageInfo.format->image_channel_data_type
+                     == CL_UNSIGNED_INT_RAW12_EXT)
+            {
+                imageInfo.width = sizes[idx][0] & ~0x1ULL;
+            }
+            else
+            {
+                imageInfo.width = sizes[idx][0];
+            }
+
+            imageInfo.height = sizes[idx][1];
+            imageInfo.rowPitch = calculate_row_pitch(imageInfo, pixelSize);
+
+            if (0 == imageInfo.width) continue;
+
+            log_info("Testing %d x %d\n", (int)imageInfo.width,
+                     (int)imageInfo.height);
 
             if( gTestMipmaps )
                 imageInfo.num_mip_levels = (size_t) random_in_range(2, compute_max_mip_levels(imageInfo.width, imageInfo.height, 0)-1, seed);
@@ -1759,7 +1779,8 @@ int test_read_image_set_2D(cl_device_id device, cl_context context,
                 imageInfo.width = (size_t)random_log_in_range( 16, maxWidthRange, seed );
                 imageInfo.height = (size_t)random_log_in_range( 16, maxHeightRange, seed );
 
-                imageInfo.rowPitch = imageInfo.width * pixelSize;
+                imageInfo.rowPitch = calculate_row_pitch(imageInfo, pixelSize);
+
                 if( gTestMipmaps )
                 {
                     imageInfo.num_mip_levels = (size_t) random_in_range(2, compute_max_mip_levels(imageInfo.width, imageInfo.height, 0)-1, seed);
@@ -1782,7 +1803,8 @@ int test_read_image_set_2D(cl_device_id device, cl_context context,
 
                     size = (size_t)imageInfo.rowPitch * (size_t)imageInfo.height * 4;
                 }
-            } while(  size > maxAllocSize || ( size * 3 ) > memSize );
+            } while (size > maxAllocSize || (size * 3) > memSize
+                     || !is_width_compatible(imageInfo));
 
             if( gDebugTrace )
                 log_info( "   at size %d,%d (row pitch %d) out of %d,%d\n", (int)imageInfo.width, (int)imageInfo.height, (int)imageInfo.rowPitch, (int)maxWidth, (int)maxHeight );