From: Junyan He <junyan...@intel.com> The cl_image will handle common logic for image of Intel platform.
Signed-off-by: Junyan He <junyan...@intel.com> --- runtime/cl_image.c | 192 +++++++++++++++++++++++++++++++++++++++++++++++++++++ runtime/cl_image.h | 35 ++++++++++ 2 files changed, 227 insertions(+) create mode 100644 runtime/cl_image.c create mode 100644 runtime/cl_image.h diff --git a/runtime/cl_image.c b/runtime/cl_image.c new file mode 100644 index 0000000..8b61110 --- /dev/null +++ b/runtime/cl_image.c @@ -0,0 +1,192 @@ +/* + * 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/>. + * + * Author: Benjamin Segovia <benjamin.sego...@intel.com> + */ + +#include "CL/cl_ext.h" +#include "cl_image.h" +#include "cl_utils.h" +#include "cl_context.h" +#include "cl_device_id.h" +#include <assert.h> + +LOCAL 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; + case CL_sRGBA: + case CL_sBGRA: + if (type != CL_UNORM_INT8) + return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR; + *bpp *= 4; + break; + case CL_NV12_INTEL: + break; + + default: + return CL_INVALID_IMAGE_FORMAT_DESCRIPTOR; + }; + + return CL_SUCCESS; +} + +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, CL_sRGBA, CL_sBGRA}; + +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); + +cl_int +cl_image_get_supported_fmt(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) +{ + size_t i, j, k, n = 0; + cl_int ret = CL_SUCCESS; + cl_bool all_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]}; + if (cl_image_order[i] >= CL_sRGBA && + ((flags & CL_MEM_WRITE_ONLY) || (flags & CL_MEM_READ_WRITE) || + (flags & CL_MEM_KERNEL_READ_AND_WRITE))) + continue; + + all_supported = CL_TRUE; + for (k = 0; k < ctx->device_num; k++) { + ret = ctx->devices[k]->api.image_format_support(ctx->devices[k], image_type, &fmt); + if (ret == CL_FALSE) { + all_supported = CL_FALSE; + break; + } + } + + if (all_supported) { + if (n < num_entries && image_formats) { + image_formats[n] = fmt; + } + n++; + } + } + } + + if (num_image_formats) + *num_image_formats = n; + return CL_SUCCESS; +} diff --git a/runtime/cl_image.h b/runtime/cl_image.h new file mode 100644 index 0000000..9343ecd --- /dev/null +++ b/runtime/cl_image.h @@ -0,0 +1,35 @@ +/* + * 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/>. + * + * Author: Benjamin Segovia <benjamin.sego...@intel.com> + */ + +#ifndef __CL_IMAGE_H__ +#define __CL_IMAGE_H__ + +#include "CL/cl.h" +#include <stdint.h> + +/* Returned when the OCL format is not supported */ +#define INTEL_UNSUPPORTED_FORMAT ((uint32_t) ~0x0u) +/* Compute the number of bytes per pixel if the format is supported */ +extern cl_int cl_image_byte_per_pixel(const cl_image_format *fmt, uint32_t *bpp); +/* Return the intel format for the given OCL format */ +extern uint32_t cl_image_get_intel_format(const cl_image_format *fmt); +/* Return the list of formats supported by the API */ +extern cl_int cl_image_get_supported_fmt(cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, + cl_uint num_entries, cl_image_format *image_formats, cl_uint *num_image_formats); +#endif /* __CL_IMAGE_H__ */ -- 2.7.4 _______________________________________________ Beignet mailing list Beignet@lists.freedesktop.org https://lists.freedesktop.org/mailman/listinfo/beignet