/*
 * Copyright © 2012 Intel Corporation
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include <string.h>
#include <assert.h>
#include "cl_context.h"
#include "cl_internals.h"
#include "cl_alloc.h"
#include "cl_driver.h"
#include "cl_device_id.h"
#include "cl_context.h"
#include "cl_platform_id.h"
#include "cl_image.h"


static const uint32_t cl_image_order[] = {
  CL_R, CL_A, CL_RG, CL_RA, CL_RGB, CL_RGBA, CL_BGRA, CL_ARGB,
  CL_INTENSITY, CL_LUMINANCE, CL_Rx, CL_RGx, CL_RGBx
};

static const uint32_t cl_image_type[] = {
  CL_SNORM_INT8, CL_SNORM_INT16, CL_UNORM_INT8, CL_UNORM_INT16,
  CL_UNORM_SHORT_565, CL_UNORM_SHORT_555, CL_UNORM_INT_101010,
  CL_SIGNED_INT8, CL_SIGNED_INT16, CL_SIGNED_INT32,
  CL_UNSIGNED_INT8, CL_UNSIGNED_INT16, CL_UNSIGNED_INT32,
  CL_HALF_FLOAT, CL_FLOAT
};

static const size_t cl_image_order_n = SIZEOF32(cl_image_order);
static const size_t cl_image_type_n = SIZEOF32(cl_image_type);

static cl_int cl_image_get_supported_fmt(cl_context ctx, cl_mem_object_type image_type, cl_uint num_entries,
    cl_image_format *image_formats, cl_uint *num_image_formats)
{
  size_t i, j, k, n = 0;
  cl_int is_supported;
  for (i = 0; i < cl_image_order_n; ++i) {
    for (j = 0; j < cl_image_type_n; ++j) {
      cl_image_format fmt = {
        .image_channel_order = cl_image_order[i],
        .image_channel_data_type = cl_image_type[j]
      };
      is_supported = CL_TRUE;

      for (k = 0; k < ctx->device_num; ++k) {
        if (ctx->devices[k]->driver->support_image_fmt(ctx->devices[k], image_type, &fmt) != CL_SUCCESS) {
          is_supported = CL_FALSE;
          break;
        }
      }

      if (is_supported == CL_FALSE)
        continue;

      if (n < num_entries && image_formats) {
        image_formats[n] = fmt;
      }

      n++;
    }
  }

  if (num_image_formats)
    *num_image_formats = n;
  return CL_SUCCESS;
}

#define FIELD_SIZE(CASE,TYPE)               \
  case JOIN(CL_,CASE):                      \
    if(param_value_size_ret)                \
      *param_value_size_ret = sizeof(TYPE); \
    if(!param_value)                        \
      return CL_SUCCESS;                    \
    if(param_value_size < sizeof(TYPE))     \
      return CL_INVALID_VALUE;              \
    break;


static cl_int cl_get_image_info(cl_mem mem, cl_image_info param_name, size_t param_value_size,
                                void *param_value, size_t *param_value_size_ret)
{
  int err = CL_SUCCESS;
  CHECK_IMAGE(mem);

  cl_mem_image image = cl_mem_to_image(mem);

  switch(param_name) {
      FIELD_SIZE(IMAGE_FORMAT, cl_image_format);
      FIELD_SIZE(IMAGE_ELEMENT_SIZE, size_t);
      FIELD_SIZE(IMAGE_ROW_PITCH, size_t);
      FIELD_SIZE(IMAGE_SLICE_PITCH, size_t);
      FIELD_SIZE(IMAGE_WIDTH, size_t);
      FIELD_SIZE(IMAGE_HEIGHT, size_t);
      FIELD_SIZE(IMAGE_DEPTH, size_t);
      FIELD_SIZE(IMAGE_ARRAY_SIZE, size_t);
      FIELD_SIZE(IMAGE_BUFFER, cl_mem);
      FIELD_SIZE(IMAGE_NUM_MIP_LEVELS, cl_uint);
      FIELD_SIZE(IMAGE_NUM_SAMPLES, cl_uint);
    default:
      return CL_INVALID_VALUE;
  }

  switch(param_name) {
    case CL_IMAGE_FORMAT:
      *(cl_image_format *)param_value = image->fmt;
      break;
    case CL_IMAGE_ELEMENT_SIZE:
      *(size_t *)param_value = image->bpp;
      break;
    case CL_IMAGE_ROW_PITCH:
      *(size_t *)param_value = image->row_pitch;
      break;
    case CL_IMAGE_SLICE_PITCH:
      *(size_t *)param_value = image->slice_pitch;
      break;
    case CL_IMAGE_WIDTH:
      *(size_t *)param_value = image->w;
      break;
    case CL_IMAGE_HEIGHT:
      *(size_t *)param_value = IS_1D_IMAGE(mem) ? 0 : image->h;
      break;
    case CL_IMAGE_DEPTH:
      *(size_t *)param_value = IS_3D_IMAGE(mem) ? image->depth : 0;
      break;
    case CL_IMAGE_ARRAY_SIZE:
      *(size_t *)param_value = IS_IMAGE_ARRAY(mem) ? image->depth : 0;
      break;
    case CL_IMAGE_BUFFER:
      *(cl_mem *)param_value = image->buffer_from;
      break;
    case CL_IMAGE_NUM_MIP_LEVELS:
    case CL_IMAGE_NUM_SAMPLES:
      // TODO: So far, no MIPs
      *(cl_mem *)param_value = 0;
      break;
  }

  return CL_SUCCESS;

error:
  return err;
}

#undef FIELD_SIZE


static cl_int
cl_image_byte_per_pixel(const cl_image_format *fmt, uint32_t *bpp)
{
  assert(bpp);

  if(fmt == NULL)
    return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;

  const uint32_t type = fmt->image_channel_data_type;
  const uint32_t order = fmt->image_channel_order;
  switch (type) {
#define DECL_BPP(DATA_TYPE, VALUE) case DATA_TYPE: *bpp = VALUE;
      DECL_BPP(CL_SNORM_INT8, 1);
      break;
      DECL_BPP(CL_SNORM_INT16, 2);
      break;
      DECL_BPP(CL_UNORM_INT8, 1);
      break;
      DECL_BPP(CL_UNORM_INT16, 2);
      break;
      DECL_BPP(CL_UNORM_SHORT_565, 2);
      if (order != CL_RGBx && order != CL_RGB)
        return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
      break;
      DECL_BPP(CL_UNORM_SHORT_555, 2);
      if (order != CL_RGBx && order != CL_RGB)
        return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
      break;
      DECL_BPP(CL_UNORM_INT_101010, 4);
      if (order != CL_RGBx && order != CL_RGB)
        return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
      break;
      DECL_BPP(CL_SIGNED_INT8, 1);
      break;
      DECL_BPP(CL_SIGNED_INT16, 2);
      break;
      DECL_BPP(CL_SIGNED_INT32, 4);
      break;
      DECL_BPP(CL_UNSIGNED_INT8, 1);
      break;
      DECL_BPP(CL_UNSIGNED_INT16, 2);
      break;
      DECL_BPP(CL_UNSIGNED_INT32, 4);
      break;
      DECL_BPP(CL_HALF_FLOAT, 2);
      break;
      DECL_BPP(CL_FLOAT, 4);
      break;
#undef DECL_BPP
    default:
      return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
  };

  switch (order) {
    case CL_Rx:
      break;
    case CL_R:
      break;
    case CL_A:
      break;
    case CL_RA:
      *bpp *= 2;
      break;
    case CL_RG:
      *bpp *= 2;
      break;
    case CL_INTENSITY:
    case CL_LUMINANCE:
      if (type != CL_UNORM_INT8 && type != CL_UNORM_INT16 &&
          type != CL_SNORM_INT8 && type != CL_SNORM_INT16 &&
          type != CL_HALF_FLOAT && type != CL_FLOAT)
        return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
      break;
    case CL_RGB:
    case CL_RGBx:
      if (type != CL_UNORM_SHORT_555 &&
          type != CL_UNORM_SHORT_565 &&
          type != CL_UNORM_INT_101010)
        return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
      break;
    case CL_RGBA:
      *bpp *= 4;
      break;
    case CL_ARGB:
    case CL_BGRA:
      if (type != CL_UNORM_INT8 && type != CL_SIGNED_INT8 &&
          type != CL_SNORM_INT8 && type != CL_UNSIGNED_INT8)
        return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
      *bpp *= 4;
      break;
    default:
      return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
  };

  return CL_SUCCESS;
}

static cl_mem _cl_mem_create_image(cl_context ctx, cl_mem_flags flags, const cl_image_format *fmt,
                                   const cl_mem_object_type image_type, size_t w, size_t h, size_t depth,
                                   size_t pitch, size_t slice_pitch, void *data, /* pointer from application */
                                   cl_mem buffer, /* for image2D from buffer */ cl_int *errcode_ret)
{
  cl_int err = CL_SUCCESS;
  cl_mem mem = NULL;
  cl_mem_image image = NULL;
  uint32_t bpp = 0;
  size_t sz = 0, aligned_pitch = 0, aligned_slice_pitch = 0, aligned_h = 0;
  cl_uint i;

  /* Check flags consistency */
  if (UNLIKELY((flags & (CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR)) && data == NULL)) {
    err = CL_INVALID_HOST_PTR;
    goto error;
  }

  /* Get the size of each pixel */
  if (UNLIKELY((err = cl_image_byte_per_pixel(fmt, &bpp)) != CL_SUCCESS))
    goto error;

  /* See if the user parameters match */
#define DO_IMAGE_ERROR            \
  do {                            \
    err = CL_INVALID_IMAGE_SIZE;  \
    goto error;                   \
  } while (0);

  if (UNLIKELY(w == 0)) DO_IMAGE_ERROR;
  if (UNLIKELY(h == 0 && (image_type != CL_MEM_OBJECT_IMAGE1D &&
                          image_type != CL_MEM_OBJECT_IMAGE1D_ARRAY &&
                          image_type != CL_MEM_OBJECT_IMAGE1D_BUFFER)))
    DO_IMAGE_ERROR;

  if (image_type == CL_MEM_OBJECT_IMAGE1D) {
    size_t min_pitch = bpp * w;
    if (data && pitch == 0)
      pitch = min_pitch;

    h = 1;
    depth = 1;
    for (i = 0; i < buffer->ctx->device_num; i++) {
      if (UNLIKELY(w > ctx->devices[i]->image2d_max_width)) DO_IMAGE_ERROR;
    }
    if (UNLIKELY(data && min_pitch > pitch)) DO_IMAGE_ERROR;
    if (UNLIKELY(data && (slice_pitch % pitch != 0))) DO_IMAGE_ERROR;
    if (UNLIKELY(!data && pitch != 0)) DO_IMAGE_ERROR;
    if (UNLIKELY(!data && slice_pitch != 0)) DO_IMAGE_ERROR;
  } else if (image_type == CL_MEM_OBJECT_IMAGE2D ||
             image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
    if (image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
      for (i = 0; i < buffer->ctx->device_num; i++) {
        if (UNLIKELY(w > ctx->devices[i]->image_max_mem_size)) DO_IMAGE_ERROR;
      }
    }

    size_t min_pitch = bpp * w;
    if (data && pitch == 0)
      pitch = min_pitch;

    for (i = 0; i < buffer->ctx->device_num; i++) {
      if (UNLIKELY(w > ctx->devices[i]->image2d_max_width)) DO_IMAGE_ERROR;
      if (UNLIKELY(h > ctx->devices[i]->image2d_max_height)) DO_IMAGE_ERROR;
    }
    if (UNLIKELY(data && min_pitch > pitch)) DO_IMAGE_ERROR;
    if (UNLIKELY(!data && pitch != 0 && buffer == NULL)) DO_IMAGE_ERROR;

    depth = 1;
  } else if (image_type == CL_MEM_OBJECT_IMAGE3D ||
             image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY ||
             image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY) {
    if (image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY) {
      h = 1;
    }

    size_t min_pitch = bpp * w;
    if (data && pitch == 0)
      pitch = min_pitch;
    size_t min_slice_pitch = pitch * h;
    if (data && slice_pitch == 0)
      slice_pitch = min_slice_pitch;

    for (i = 0; i < buffer->ctx->device_num; i++) {
      if (UNLIKELY(w > ctx->devices[i]->image3d_max_width)) DO_IMAGE_ERROR;
      if (UNLIKELY(h > ctx->devices[i]->image3d_max_height)) DO_IMAGE_ERROR;

      if (image_type == CL_MEM_OBJECT_IMAGE3D &&
          (UNLIKELY(depth > ctx->devices[i]->image3d_max_depth))) {
        DO_IMAGE_ERROR;
      } else if (UNLIKELY(depth > ctx->devices[i]->image_max_array_size)) {
        DO_IMAGE_ERROR;
      }
    }

    if (UNLIKELY(data && min_pitch > pitch)) DO_IMAGE_ERROR;
    if (UNLIKELY(data && min_slice_pitch > slice_pitch)) DO_IMAGE_ERROR;
    if (UNLIKELY(!data && pitch != 0)) DO_IMAGE_ERROR;
    if (UNLIKELY(!data && slice_pitch != 0)) DO_IMAGE_ERROR;
  } else
    assert(0);

#undef DO_IMAGE_ERROR

  aligned_pitch = w * bpp;
  aligned_h = h;

  //the pitch should be same with buffer's pitch as they share same buffer.
  if (image_type == CL_MEM_OBJECT_IMAGE2D && buffer != NULL) {
    if(aligned_pitch < pitch) {
      aligned_pitch = pitch;
    }
  }

  sz = aligned_pitch * aligned_h * depth;
  if (image_type == CL_MEM_OBJECT_IMAGE2D && buffer != NULL)  {
    //image 2d created from buffer: per spec, the buffer sz maybe larger than the image 2d.
    if (buffer->size >= sz)
      sz = buffer->size;
    else {
      err = CL_INVALID_IMAGE_SIZE;
      goto error;
    }
  }

  mem = cl_mem_new(image_type, ctx, flags, sz);
  if (mem == NULL) {
    err = CL_OUT_OF_HOST_MEMORY;
    goto error;
  }

  image = cl_mem_to_image(mem);

  if (image_type == CL_MEM_OBJECT_IMAGE1D ||
      image_type == CL_MEM_OBJECT_IMAGE2D ||
      image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER)
    aligned_slice_pitch = 0;
  else
    aligned_slice_pitch = aligned_pitch*aligned_h;

  image->w = w;
  image->h = h;
  image->depth = depth;
  image->fmt = *fmt;
  image->bpp = bpp;
  image->row_pitch = aligned_pitch;
  image->slice_pitch = aligned_slice_pitch;

  if (flags & CL_MEM_USE_HOST_PTR) {
    mem->host_ptr = data;
    image->host_row_pitch = pitch;
    image->host_slice_pitch = slice_pitch;
  }

exit:
  if (errcode_ret)
    *errcode_ret = err;
  return mem;
error:
  cl_release_mem(mem);
  mem = NULL;
  goto exit;
}

static cl_mem _cl_mem_create_image_from_buffer(cl_context ctx, cl_mem_flags flags,
    const cl_image_format* image_format, const cl_image_desc *image_desc,
    cl_int *errcode_ret)
{
  cl_mem image = NULL;
  cl_mem buffer = image_desc->buffer;
  cl_int err = CL_SUCCESS;
  cl_ulong max_size;
  cl_mem_flags merged_flags;
  uint32_t bpp;
  cl_uint i;

  /* Get the size of each pixel */
  if (UNLIKELY((err = cl_image_byte_per_pixel(image_format, &bpp)) != CL_SUCCESS))
    goto error;

  if (!buffer) {
    err = CL_INVALID_IMAGE_DESCRIPTOR;
    goto error;
  }

  if (flags & (CL_MEM_USE_HOST_PTR|CL_MEM_ALLOC_HOST_PTR|CL_MEM_COPY_HOST_PTR)) {
    err = CL_INVALID_IMAGE_DESCRIPTOR;
    goto error;
  }

  /* access check. */
  if ((buffer->flags & CL_MEM_WRITE_ONLY) &&
      (flags & (CL_MEM_READ_WRITE|CL_MEM_READ_ONLY))) {
    err = CL_INVALID_VALUE;
    goto error;
  }
  if ((buffer->flags & CL_MEM_READ_ONLY) &&
      (flags & (CL_MEM_READ_WRITE|CL_MEM_WRITE_ONLY))) {
    err = CL_INVALID_VALUE;
    goto error;
  }
  if ((buffer->flags & CL_MEM_HOST_WRITE_ONLY) &&
      (flags & CL_MEM_HOST_READ_ONLY)) {
    err = CL_INVALID_VALUE;
    goto error;
  }
  if ((buffer->flags & CL_MEM_HOST_READ_ONLY) &&
      (flags & CL_MEM_HOST_WRITE_ONLY)) {
    err = CL_INVALID_VALUE;
    goto error;
  }
  if ((buffer->flags & CL_MEM_HOST_NO_ACCESS) &&
      (flags & (CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_WRITE_ONLY))) {
    err = CL_INVALID_VALUE;
    goto error;
  }

  for (i = 0; i < buffer->ctx->device_num; i++) {
    if ((err = cl_get_device_info(ctx->devices[i], CL_DEVICE_IMAGE_MAX_BUFFER_SIZE,
                                  sizeof(max_size), &max_size, NULL)) != CL_SUCCESS) {
      goto error;
    }

    if (image_desc->image_width > max_size) {
      err = CL_INVALID_IMAGE_DESCRIPTOR;
      goto error;
    }
  }

  if (image_desc->image_width*bpp > buffer->size) {
    err = CL_INVALID_IMAGE_DESCRIPTOR;
    goto error;
  }

  merged_flags = buffer->flags;
  if (flags & (CL_MEM_READ_WRITE|CL_MEM_READ_WRITE|CL_MEM_WRITE_ONLY)) {
    merged_flags &= ~(CL_MEM_READ_WRITE|CL_MEM_READ_WRITE|CL_MEM_WRITE_ONLY);
    merged_flags |= flags & (CL_MEM_READ_WRITE|CL_MEM_READ_WRITE|CL_MEM_WRITE_ONLY);
  }
  if (flags & (CL_MEM_HOST_WRITE_ONLY|CL_MEM_HOST_READ_ONLY|CL_MEM_HOST_NO_ACCESS)) {
    merged_flags &= ~(CL_MEM_HOST_WRITE_ONLY|CL_MEM_HOST_READ_ONLY|CL_MEM_HOST_NO_ACCESS);
    merged_flags |= flags & (CL_MEM_HOST_WRITE_ONLY|CL_MEM_HOST_READ_ONLY|CL_MEM_HOST_NO_ACCESS);
  }

  if(image_desc->image_type == CL_MEM_OBJECT_IMAGE2D || image_desc->image_type == CL_MEM_OBJECT_IMAGE1D_BUFFER) {
    image = _cl_mem_create_image(ctx, flags, image_format, image_desc->image_type, image_desc->image_width,
                                 image_desc->image_height, image_desc->image_depth, image_desc->image_row_pitch,
                                 image_desc->image_slice_pitch, NULL, image_desc->buffer, errcode_ret);
  } else
    assert(0);

  if (image == NULL)
    return NULL;

  if (err != CL_SUCCESS)
    goto error;

  /* Now point to the right offset if buffer is a SUB_BUFFER. */
  if (buffer->flags & CL_MEM_USE_HOST_PTR)
    image->host_ptr = buffer->host_ptr;

  cl_retain_mem(buffer);
  cl_mem_to_image(image)->buffer_from = buffer;
  *errcode_ret = err;
  return image;

error:
  if (image)
    cl_release_mem(image);

  image = NULL;
  if (errcode_ret)
    *errcode_ret = err;

  return image;
}

static cl_mem cl_mem_create_image(cl_context context, cl_mem_flags flags, const cl_image_format *image_format,
                                  const cl_image_desc *image_desc, void *host_ptr, cl_int *errcode_ret)
{
  cl_mem image = NULL;
  cl_int err = CL_SUCCESS;
  cl_uint i;

  switch (image_desc->image_type) {
    case CL_MEM_OBJECT_IMAGE1D:
    case CL_MEM_OBJECT_IMAGE3D:
      image = _cl_mem_create_image(context, flags, image_format, image_desc->image_type,
                                   image_desc->image_width, image_desc->image_height, image_desc->image_depth,
                                   image_desc->image_row_pitch, image_desc->image_slice_pitch,
                                   host_ptr, NULL, &err);
    case CL_MEM_OBJECT_IMAGE2D:
      if(image_desc->buffer)
        image = _cl_mem_create_image_from_buffer(context, flags, image_format, image_desc, &err);
      else
        image = _cl_mem_create_image(context, flags, image_format, image_desc->image_type,
                                     image_desc->image_width, image_desc->image_height, image_desc->image_depth,
                                     image_desc->image_row_pitch, image_desc->image_slice_pitch,
                                     host_ptr, NULL, &err);
    case CL_MEM_OBJECT_IMAGE1D_ARRAY:
    case CL_MEM_OBJECT_IMAGE2D_ARRAY:
      image = _cl_mem_create_image(context, flags, image_format, image_desc->image_type,
                                   image_desc->image_width, image_desc->image_height, image_desc->image_array_size,
                                   image_desc->image_row_pitch, image_desc->image_slice_pitch,
                                   host_ptr, NULL, &err);
    case CL_MEM_OBJECT_IMAGE1D_BUFFER:
      image = _cl_mem_create_image_from_buffer(context, flags, image_format, image_desc, &err);
      break;
    case CL_MEM_OBJECT_BUFFER:
    default:
      assert(0);
  }

  if (image) {
    for (i = 0; i < image->ctx->device_num; i++) {
      err = image->ctx->devices[i]->driver->create_image(image,
            image->ctx->devices[i], context, flags, image_format, image_desc, host_ptr);
      if (err != CL_SUCCESS)
        break;
    }
  }

  if (err != CL_SUCCESS) {
    cl_release_mem(image);
    image = NULL;
  }

  if (errcode_ret)
    *errcode_ret = err;

  return image;
}

/**************************************************************************************
 *************************           CL APIs           ********************************
 **************************************************************************************/
cl_int
clGetImageInfo(cl_mem		  mem,
               cl_image_info  param_name,
               size_t		  param_value_size,
               void *		  param_value,
               size_t * 	  param_value_size_ret)
{
  return cl_get_image_info(mem, param_name, param_value_size,
                           param_value, param_value_size_ret);
}

cl_mem
clCreateImage(cl_context context,
              cl_mem_flags flags,
              const cl_image_format *image_format,
              const cl_image_desc *image_desc,
              void *host_ptr,
              cl_int * errcode_ret)
{
  cl_mem mem = NULL;
  cl_int err = CL_SUCCESS;
  CHECK_CONTEXT (context);

  if (image_format == NULL) {
    err = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
    goto error;
  }

  if (image_format->image_channel_order < CL_R ||
      image_format->image_channel_order > CL_RGBx) {
    err = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
    goto error;
  }

  if (image_format->image_channel_data_type < CL_SNORM_INT8 ||
      image_format->image_channel_data_type > CL_FLOAT) {
    err = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR;
    goto error;
  }

  if (image_desc == NULL) {
    err = CL_INVALID_IMAGE_DESCRIPTOR;
    goto error;
  }

  if (image_desc->image_type <= CL_MEM_OBJECT_BUFFER ||
      image_desc->image_type > CL_MEM_OBJECT_IMAGE1D_BUFFER) {
    err = CL_INVALID_IMAGE_DESCRIPTOR;
    goto error;
  }

  /* buffer refers to a valid buffer memory object if image_type is
     CL_MEM_OBJECT_IMAGE1D_BUFFER or CL_MEM_OBJECT_IMAGE2D. Otherwise it must be NULL. */
  if (image_desc->image_type != CL_MEM_OBJECT_IMAGE1D_BUFFER &&
      image_desc->image_type != CL_MEM_OBJECT_IMAGE2D &&
      image_desc->buffer) {
    err = CL_INVALID_IMAGE_DESCRIPTOR;
    goto error;
  }

  if (image_desc->num_mip_levels || image_desc->num_samples) {
    err = CL_INVALID_IMAGE_DESCRIPTOR;
    goto error;
  }

  /* Other details check for image_desc will leave to image create. */
  mem = cl_mem_create_image(context, flags, image_format, image_desc,
                            host_ptr, &err);
error:
  if (errcode_ret)
    *errcode_ret = err;
  return mem;
}

cl_int
clGetSupportedImageFormats(cl_context         ctx,
                           cl_mem_flags       flags,
                           cl_mem_object_type image_type,
                           cl_uint            num_entries,
                           cl_image_format *  image_formats,
                           cl_uint *          num_image_formats)
{
  cl_int err = CL_SUCCESS;
  CHECK_CONTEXT (ctx);
  if (UNLIKELY(num_entries == 0 && image_formats != NULL)) {
    err = CL_INVALID_VALUE;
    goto error;
  }
  if (UNLIKELY(image_type != CL_MEM_OBJECT_IMAGE1D &&
               image_type != CL_MEM_OBJECT_IMAGE1D_ARRAY &&
               image_type != CL_MEM_OBJECT_IMAGE1D_BUFFER &&
               image_type != CL_MEM_OBJECT_IMAGE2D_ARRAY &&
               image_type != CL_MEM_OBJECT_IMAGE2D &&
               image_type != CL_MEM_OBJECT_IMAGE3D)) {
    err = CL_INVALID_VALUE;
    goto error;
  }
  err = cl_image_get_supported_fmt(ctx,
                                   image_type,
                                   num_entries,
                                   image_formats,
                                   num_image_formats);

error:
  return err;
}