OpenCL-CTS/test_conformance/basic/test_simple_image_pitch.cpp

//
// 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 "harness/compat.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "testBase.h"

REGISTER_TEST(simple_read_image_pitch)
{
  cl_int err = CL_SUCCESS;

  size_t imageW = 143;
  size_t imageH = 151;
  size_t bufferW = 151*4;
  size_t bufferH = 151;

  size_t pixel_bytes = 4;
  size_t image_bytes = imageW * imageH * pixel_bytes;

  size_t buffer_bytes = bufferW * bufferH;

  PASSIVE_REQUIRE_IMAGE_SUPPORT( device );

  char* host_image = (char*)malloc(image_bytes);
  memset(host_image,0x1,image_bytes);

  cl_image_format fmt = { 0 };
  fmt.image_channel_order     = CL_RGBA;
  fmt.image_channel_data_type = CL_UNORM_INT8;

  cl_image_desc desc = { 0 };
  desc.image_type         = CL_MEM_OBJECT_IMAGE2D;
  desc.image_width        = imageW;
  desc.image_height       = imageH;

  cl_mem image =
      clCreateImage(context, CL_MEM_COPY_HOST_PTR | CL_MEM_READ_WRITE, &fmt,
                    &desc, host_image, &err);
  test_error(err,"clCreateImage");

  char* host_buffer = (char*)malloc(buffer_bytes);
  memset(host_buffer,0xa,buffer_bytes);

  // Test reading from the image
  size_t origin[] = { 0, 0, 0 };
  size_t region[] = { imageW, imageH, 1 };

  err = clEnqueueReadImage(queue, image, CL_TRUE, origin, region, bufferW, 0,
                           host_buffer, 0, NULL, NULL);
  test_error(err,"clEnqueueReadImage");

  size_t errors = 0;
  for (size_t j=0;j<bufferH;++j) {
    for (size_t i=0;i<bufferW;++i) {
      char val = host_buffer[j*bufferW+i];
      if ((i<imageW*pixel_bytes) && (val != 0x1)) {
          log_error("Bad value %x in image at (byte: %zu, row: %zu)\n", val, i,
                    j);
          ++errors;
      }
      else if ((i>=imageW*pixel_bytes) && (val != 0xa)) {
          log_error("Bad value %x outside image at (byte: %zu, row: %zu)\n",
                    val, i, j);
          ++errors;
      }
    }
  }

  test_error(clReleaseMemObject(image),"clReleaseMemObject");
  free(host_image);
  free(host_buffer);

  return errors == 0 ? TEST_PASS : TEST_FAIL;
}

REGISTER_TEST(simple_write_image_pitch)
{
  cl_int err = CL_SUCCESS;

  size_t imageW = 143;
  size_t imageH = 151;
  size_t bufferW = 151*4;
  size_t bufferH = 151;

  size_t pixel_bytes = 4;
  size_t image_bytes = imageW * imageH * pixel_bytes;

  size_t buffer_bytes = bufferW * bufferH;

  PASSIVE_REQUIRE_IMAGE_SUPPORT( device );

  char* host_image = (char*)malloc(image_bytes);
  memset(host_image,0x0,image_bytes);

  cl_image_format fmt = { 0 };
  fmt.image_channel_order     = CL_RGBA;
  fmt.image_channel_data_type = CL_UNORM_INT8;

  cl_image_desc desc = { 0 };
  desc.image_type         = CL_MEM_OBJECT_IMAGE2D;
  desc.image_width        = imageW;
  desc.image_height       = imageH;

  cl_mem image =
      clCreateImage(context, CL_MEM_COPY_HOST_PTR | CL_MEM_READ_WRITE, &fmt,
                    &desc, host_image, &err);
  test_error(err,"clCreateImage");

  char* host_buffer = (char*)malloc(buffer_bytes);
  memset(host_buffer,0xa,buffer_bytes);

  // Test reading from the image
  size_t origin[] = { 0, 0, 0 };
  size_t region[] = { imageW, imageH, 1 };

  err = clEnqueueWriteImage(queue, image, CL_TRUE, origin, region, bufferW, 0,
                            host_buffer, 0, NULL, NULL);
  test_error(err,"clEnqueueWriteImage");

  size_t mapped_pitch = 0;
  char* mapped_image = (char*)clEnqueueMapImage(
      queue, image, CL_TRUE, CL_MAP_READ, origin, region, &mapped_pitch, NULL,
      0, NULL, NULL, &err);
  test_error(err,"clEnqueueMapImage");

  size_t errors = 0;
  for (size_t j=0;j<imageH;++j) {
    for (size_t i=0;i<mapped_pitch;++i) {
      char val = mapped_image[j*mapped_pitch+i];
      if ((i<imageW*pixel_bytes) && (val != 0xa)) {
          log_error("Bad value %x in image at (byte: %zu, row: %zu)\n", val, i,
                    j);
          ++errors;
      }
    }
  }

  err = clEnqueueUnmapMemObject(queue, image, (void*)mapped_image, 0, 0, 0);
  test_error(err,"clEnqueueUnmapMemObject");

  test_error(clReleaseMemObject(image),"clReleaseMemObject");
  free(host_image);
  free(host_buffer);

  return errors == 0 ? TEST_PASS : TEST_FAIL;
}