CL: image object creation for front end and pass-through

src/libANGLE/CLBuffer.cpp

@@ -20,14 +20,8 @@ cl_mem Buffer::createSubBuffer(cl_mem_flags flags,
                                cl_int *errcodeRet)
 {
     const cl_buffer_region &region = *static_cast<const cl_buffer_region *>(createInfo);
-    mContext->mMemories.emplace_back(
-        new Buffer(*this, flags, region.origin, region.size, errcodeRet));
-    if (!mContext->mMemories.back()->mImpl)
-    {
-        mContext->mMemories.back()->release();
-        return nullptr;
-    }
-    return mContext->mMemories.back().get();
+    return mContext->createMemory(new Buffer(*this, flags, region.origin, region.size, errcodeRet),
+                                  errcodeRet);
 }
 
 Buffer::Buffer(Context &context,

src/libANGLE/CLCommandQueue.cpp

@@ -37,7 +37,7 @@ bool CommandQueue::release()
 cl_int CommandQueue::getInfo(CommandQueueInfo name,
                              size_t valueSize,
                              void *value,
-                             size_t *valueSizeRet)
+                             size_t *valueSizeRet) const
 {
     void *valPointer      = nullptr;
     const void *copyValue = nullptr;

src/libANGLE/CLCommandQueue.h

@@ -37,7 +37,11 @@ class CommandQueue final : public _cl_command_queue, public Object
     void retain() noexcept;
     bool release();
 
-    cl_int getInfo(CommandQueueInfo name, size_t valueSize, void *value, size_t *valueSizeRet);
+    cl_int getInfo(CommandQueueInfo name,
+                   size_t valueSize,
+                   void *value,
+                   size_t *valueSizeRet) const;
+
     cl_int setProperty(cl_command_queue_properties properties,
                        cl_bool enable,
                        cl_command_queue_properties *oldProperties);

src/libANGLE/CLContext.cpp

@@ -8,6 +8,7 @@
 #include "libANGLE/CLContext.h"
 
 #include "libANGLE/CLBuffer.h"
+#include "libANGLE/CLImage.h"
 #include "libANGLE/CLPlatform.h"
 
 #include <cstring>
@@ -27,7 +28,7 @@ bool Context::release()
     return released;
 }
 
-cl_int Context::getInfo(ContextInfo name, size_t valueSize, void *value, size_t *valueSizeRet)
+cl_int Context::getInfo(ContextInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const
 {
     cl_uint numDevices    = 0u;
     const void *copyValue = nullptr;
@@ -80,14 +81,9 @@ cl_command_queue Context::createCommandQueue(cl_device_id device,
                                              cl_command_queue_properties properties,
                                              cl_int *errcodeRet)
 {
-    mCommandQueues.emplace_back(
-        new CommandQueue(*this, *static_cast<Device *>(device), properties, errcodeRet));
-    if (!mCommandQueues.back()->mImpl)
-    {
-        mCommandQueues.back()->release();
-        return nullptr;
-    }
-    return mCommandQueues.back().get();
+    return createCommandQueue(
+        new CommandQueue(*this, *static_cast<Device *>(device), properties, errcodeRet),
+        errcodeRet);
 }
 
 cl_command_queue Context::createCommandQueueWithProperties(cl_device_id device,
@@ -117,15 +113,9 @@ cl_command_queue Context::createCommandQueueWithProperties(cl_device_id device,
         propArray.reserve(propIt - properties);
         propArray.insert(propArray.cend(), properties, propIt);
     }
-
-    mCommandQueues.emplace_back(new CommandQueue(*this, *static_cast<Device *>(device),
-                                                 std::move(propArray), props, size, errcodeRet));
-    if (!mCommandQueues.back()->mImpl)
-    {
-        mCommandQueues.back()->release();
-        return nullptr;
-    }
-    return mCommandQueues.back().get();
+    return createCommandQueue(new CommandQueue(*this, *static_cast<Device *>(device),
+                                               std::move(propArray), props, size, errcodeRet),
+                              errcodeRet);
 }
 
 cl_mem Context::createBuffer(const cl_mem_properties *properties,
@@ -134,13 +124,53 @@ cl_mem Context::createBuffer(const cl_mem_properties *properties,
                              void *hostPtr,
                              cl_int *errcodeRet)
 {
-    mMemories.emplace_back(new Buffer(*this, {}, flags, size, hostPtr, errcodeRet));
-    if (!mMemories.back()->mImpl)
-    {
-        mMemories.back()->release();
-        return nullptr;
-    }
-    return mMemories.back().get();
+    return createMemory(new Buffer(*this, {}, flags, size, hostPtr, errcodeRet), errcodeRet);
+}
+
+cl_mem Context::createImage(const cl_mem_properties *properties,
+                            cl_mem_flags flags,
+                            const cl_image_format *format,
+                            const cl_image_desc *desc,
+                            void *hostPtr,
+                            cl_int *errcodeRet)
+{
+    const ImageDescriptor imageDesc = {
+        desc->image_type,        desc->image_width,      desc->image_height,
+        desc->image_depth,       desc->image_array_size, desc->image_row_pitch,
+        desc->image_slice_pitch, desc->num_mip_levels,   desc->num_samples};
+    return createMemory(new Image(*this, {}, flags, *format, imageDesc,
+                                  static_cast<Memory *>(desc->buffer), hostPtr, errcodeRet),
+                        errcodeRet);
+}
+
+cl_mem Context::createImage2D(cl_mem_flags flags,
+                              const cl_image_format *format,
+                              size_t width,
+                              size_t height,
+                              size_t rowPitch,
+                              void *hostPtr,
+                              cl_int *errcodeRet)
+{
+    const ImageDescriptor imageDesc = {
+        CL_MEM_OBJECT_IMAGE2D, width, height, 0u, 0u, rowPitch, 0u, 0u, 0u};
+    return createMemory(
+        new Image(*this, {}, flags, *format, imageDesc, nullptr, hostPtr, errcodeRet), errcodeRet);
+}
+
+cl_mem Context::createImage3D(cl_mem_flags flags,
+                              const cl_image_format *format,
+                              size_t width,
+                              size_t height,
+                              size_t depth,
+                              size_t rowPitch,
+                              size_t slicePitch,
+                              void *hostPtr,
+                              cl_int *errcodeRet)
+{
+    const ImageDescriptor imageDesc = {
+        CL_MEM_OBJECT_IMAGE3D, width, height, depth, 0u, rowPitch, slicePitch, 0u, 0u};
+    return createMemory(
+        new Image(*this, {}, flags, *format, imageDesc, nullptr, hostPtr, errcodeRet), errcodeRet);
 }
 
 bool Context::IsValid(const _cl_context *context)
@@ -189,6 +219,36 @@ Context::Context(Platform &platform,
       mUserData(userData)
 {}
 
+cl_command_queue Context::createCommandQueue(CommandQueue *commandQueue, cl_int *errcodeRet)
+{
+    mCommandQueues.emplace_back(commandQueue);
+    if (!mCommandQueues.back()->mImpl)
+    {
+        mCommandQueues.back()->release();
+        return nullptr;
+    }
+    if (errcodeRet != nullptr)
+    {
+        *errcodeRet = CL_SUCCESS;
+    }
+    return mCommandQueues.back().get();
+}
+
+cl_mem Context::createMemory(Memory *memory, cl_int *errcodeRet)
+{
+    mMemories.emplace_back(memory);
+    if (!mMemories.back()->mImpl || mMemories.back()->mSize == 0u)
+    {
+        mMemories.back()->release();
+        return nullptr;
+    }
+    if (errcodeRet != nullptr)
+    {
+        *errcodeRet = CL_SUCCESS;
+    }
+    return mMemories.back().get();
+}
+
 void Context::destroyCommandQueue(CommandQueue *commandQueue)
 {
     auto commandQueueIt = mCommandQueues.cbegin();

src/libANGLE/CLContext.h

@@ -35,7 +35,7 @@ class Context final : public _cl_context, public Object
     void retain() noexcept;
     bool release();
 
-    cl_int getInfo(ContextInfo name, size_t valueSize, void *value, size_t *valueSizeRet);
+    cl_int getInfo(ContextInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
 
     cl_command_queue createCommandQueue(cl_device_id device,
                                         cl_command_queue_properties properties,
@@ -51,6 +51,31 @@ class Context final : public _cl_context, public Object
                         void *hostPtr,
                         cl_int *errcodeRet);
 
+    cl_mem createImage(const cl_mem_properties *properties,
+                       cl_mem_flags flags,
+                       const cl_image_format *format,
+                       const cl_image_desc *desc,
+                       void *hostPtr,
+                       cl_int *errcodeRet);
+
+    cl_mem createImage2D(cl_mem_flags flags,
+                         const cl_image_format *format,
+                         size_t width,
+                         size_t height,
+                         size_t rowPitch,
+                         void *hostPtr,
+                         cl_int *errcodeRet);
+
+    cl_mem createImage3D(cl_mem_flags flags,
+                         const cl_image_format *format,
+                         size_t width,
+                         size_t height,
+                         size_t depth,
+                         size_t rowPitch,
+                         size_t slicePitch,
+                         void *hostPtr,
+                         cl_int *errcodeRet);
+
     static bool IsValid(const _cl_context *context);
 
   private:
@@ -70,6 +95,9 @@ class Context final : public _cl_context, public Object
             bool userSync,
             cl_int *errcodeRet);
 
+    cl_command_queue createCommandQueue(CommandQueue *commandQueue, cl_int *errcodeRet);
+    cl_mem createMemory(Memory *memory, cl_int *errcodeRet);
+
     void destroyCommandQueue(CommandQueue *commandQueue);
     void destroyMemory(Memory *memory);
 

src/libANGLE/CLDevice.cpp

@@ -36,7 +36,7 @@ bool Device::release()
     return released;
 }
 
-cl_int Device::getInfo(DeviceInfo name, size_t valueSize, void *value, size_t *valueSizeRet)
+cl_int Device::getInfo(DeviceInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const
 {
     static_assert(std::is_same<cl_uint, cl_bool>::value &&
                       std::is_same<cl_uint, cl_device_mem_cache_type>::value &&

src/libANGLE/CLDevice.h

@@ -41,7 +41,7 @@ class Device final : public _cl_device_id, public Object
     cl_int getInfoUInt(DeviceInfo name, cl_uint *value) const;
     cl_int getInfoULong(DeviceInfo name, cl_ulong *value) const;
 
-    cl_int getInfo(DeviceInfo name, size_t valueSize, void *value, size_t *valueSizeRet);
+    cl_int getInfo(DeviceInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
 
     cl_int createSubDevices(const cl_device_partition_property *properties,
                             cl_uint numDevices,

src/libANGLE/CLImage.cpp

+//
+// Copyright 2021 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// CLImage.cpp: Implements the cl::Image class.
+
+#include "libANGLE/CLImage.h"
+
+#include "libANGLE/cl_utils.h"
+
+#include <cstring>
+
+namespace cl
+{
+
+Image::~Image() = default;
+
+cl_int Image::getInfo(ImageInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const
+{
+    size_t valSizeT       = 0u;
+    void *valPointer      = nullptr;
+    const void *copyValue = nullptr;
+    size_t copySize       = 0u;
+
+    switch (name)
+    {
+        case ImageInfo::Format:
+            copyValue = &mFormat;
+            copySize  = sizeof(mFormat);
+            break;
+        case ImageInfo::ElementSize:
+            valSizeT  = GetElementSize(mFormat);
+            copyValue = &valSizeT;
+            copySize  = sizeof(valSizeT);
+            break;
+        case ImageInfo::RowPitch:
+            copyValue = &mDesc.rowPitch;
+            copySize  = sizeof(mDesc.rowPitch);
+            break;
+        case ImageInfo::SlicePitch:
+            copyValue = &mDesc.slicePitch;
+            copySize  = sizeof(mDesc.slicePitch);
+            break;
+        case ImageInfo::Width:
+            copyValue = &mDesc.width;
+            copySize  = sizeof(mDesc.width);
+            break;
+        case ImageInfo::Height:
+            copyValue = &mDesc.height;
+            copySize  = sizeof(mDesc.height);
+            break;
+        case ImageInfo::Depth:
+            copyValue = &mDesc.depth;
+            copySize  = sizeof(mDesc.depth);
+            break;
+        case ImageInfo::ArraySize:
+            copyValue = &mDesc.arraySize;
+            copySize  = sizeof(mDesc.arraySize);
+            break;
+        case ImageInfo::Buffer:
+            valPointer = static_cast<cl_mem>(mParent.get());
+            copyValue  = &valPointer;
+            copySize   = sizeof(valPointer);
+            break;
+        case ImageInfo::NumMipLevels:
+            copyValue = &mDesc.numMipLevels;
+            copySize  = sizeof(mDesc.numMipLevels);
+            break;
+        case ImageInfo::NumSamples:
+            copyValue = &mDesc.numSamples;
+            copySize  = sizeof(mDesc.numSamples);
+            break;
+        default:
+            return CL_INVALID_VALUE;
+    }
+
+    if (value != nullptr)
+    {
+        if (valueSize < copySize)
+        {
+            return CL_INVALID_VALUE;
+        }
+        if (copyValue != nullptr)
+        {
+            std::memcpy(value, copyValue, copySize);
+        }
+    }
+    if (valueSizeRet != nullptr)
+    {
+        *valueSizeRet = copySize;
+    }
+    return CL_SUCCESS;
+}
+
+bool Image::IsValid(const _cl_mem *image)
+{
+    if (!Memory::IsValid(image))
+    {
+        return false;
+    }
+    switch (static_cast<const Memory *>(image)->getType())
+    {
+        case CL_MEM_OBJECT_IMAGE1D:
+        case CL_MEM_OBJECT_IMAGE2D:
+        case CL_MEM_OBJECT_IMAGE3D:
+        case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+        case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+        case CL_MEM_OBJECT_IMAGE1D_BUFFER:
+            break;
+        default:
+            return false;
+    }
+    return true;
+}
+
+Image::Image(Context &context,
+             PropArray &&properties,
+             cl_mem_flags flags,
+             const cl_image_format &format,
+             const ImageDescriptor &desc,
+             Memory *parent,
+             void *hostPtr,
+             cl_int *errcodeRet)
+    : Memory(*this,
+             context,
+             std::move(properties),
+             flags,
+             format,
+             desc,
+             parent,
+             hostPtr,
+             errcodeRet),
+      mFormat(format),
+      mDesc(desc)
+{}
+
+}  // namespace cl

src/libANGLE/CLImage.h

+//
+// Copyright 2021 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// CLImage.h: Defines the cl::Image class, which stores a texture, frame-buffer or image.
+
+#ifndef LIBANGLE_CLIMAGE_H_
+#define LIBANGLE_CLIMAGE_H_
+
+#include "libANGLE/CLMemory.h"
+
+namespace cl
+{
+
+class Image final : public Memory
+{
+  public:
+    ~Image() override;
+
+    cl_mem_object_type getType() const final;
+
+    const cl_image_format &getFormat() const;
+    const ImageDescriptor &getDescriptor() const;
+
+    cl_int getInfo(ImageInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
+
+    static bool IsValid(const _cl_mem *image);
+
+  private:
+    Image(Context &context,
+          PropArray &&properties,
+          cl_mem_flags flags,
+          const cl_image_format &format,
+          const ImageDescriptor &desc,
+          Memory *parent,
+          void *hostPtr,
+          cl_int *errcodeRet);
+
+    const cl_image_format mFormat;
+    const ImageDescriptor mDesc;
+
+    friend class Context;
+};
+
+inline cl_mem_object_type Image::getType() const
+{
+    return mDesc.type;
+}
+
+inline const cl_image_format &Image::getFormat() const
+{
+    return mFormat;
+}
+
+inline const ImageDescriptor &Image::getDescriptor() const
+{
+    return mDesc;
+}
+
+}  // namespace cl
+
+#endif  // LIBANGLE_CLIMAGE_H_

src/libANGLE/CLMemory.cpp

@@ -28,7 +28,7 @@ bool Memory::release()
     return released;
 }
 
-cl_int Memory::getInfo(MemInfo name, size_t valueSize, void *value, size_t *valueSizeRet)
+cl_int Memory::getInfo(MemInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const
 {
     static_assert(
         std::is_same<cl_uint, cl_bool>::value && std::is_same<cl_uint, cl_mem_object_type>::value,
@@ -152,4 +152,23 @@ Memory::Memory(const Buffer &buffer,
       mSize(size)
 {}
 
+Memory::Memory(const Image &image,
+               Context &context,
+               PropArray &&properties,
+               cl_mem_flags flags,
+               const cl_image_format &format,
+               const ImageDescriptor &desc,
+               Memory *parent,
+               void *hostPtr,
+               cl_int *errcodeRet)
+    : _cl_mem(context.getDispatch()),
+      mContext(&context),
+      mProperties(std::move(properties)),
+      mFlags(flags),
+      mHostPtr((flags & CL_MEM_USE_HOST_PTR) != 0u ? hostPtr : nullptr),
+      mParent(parent),
+      mImpl(context.mImpl->createImage(image, format, desc, hostPtr, errcodeRet)),
+      mSize(mImpl ? mImpl->getSize() : 0u)
+{}
+
 }  // namespace cl

src/libANGLE/CLMemory.h

@@ -35,7 +35,7 @@ class Memory : public _cl_mem, public Object
     void retain() noexcept;
     bool release();
 
-    cl_int getInfo(MemInfo name, size_t valueSize, void *value, size_t *valueSizeRet);
+    cl_int getInfo(MemInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
 
     static bool IsValid(const _cl_mem *memory);
 
@@ -55,6 +55,16 @@ class Memory : public _cl_mem, public Object
            size_t size,
            cl_int *errcodeRet);
 
+    Memory(const Image &image,
+           Context &context,
+           PropArray &&properties,
+           cl_mem_flags flags,
+           const cl_image_format &format,
+           const ImageDescriptor &desc,
+           Memory *parent,
+           void *hostPtr,
+           cl_int *errcodeRet);
+
     const ContextRefPtr mContext;
     const PropArray mProperties;
     const cl_mem_flags mFlags;

src/libANGLE/CLObject.h

@@ -22,7 +22,7 @@ class Object
     virtual ~Object();
 
     cl_uint getRefCount() { return mRefCount; }
-    const cl_uint *getRefCountPtr() { return &mRefCount; }
+    const cl_uint *getRefCountPtr() const { return &mRefCount; }
 
   protected:
     void addRef() noexcept { ++mRefCount; }

src/libANGLE/CLPlatform.cpp

@@ -64,7 +64,10 @@ Platform::~Platform()
     removeRef();
 }
 
-cl_int Platform::getInfo(PlatformInfo name, size_t valueSize, void *value, size_t *valueSizeRet)
+cl_int Platform::getInfo(PlatformInfo name,
+                         size_t valueSize,
+                         void *value,
+                         size_t *valueSizeRet) const
 {
     const void *copyValue = nullptr;
     size_t copySize       = 0u;
@@ -200,16 +203,10 @@ cl_context Platform::CreateContext(const cl_context_properties *properties,
     {
         refDevices.emplace_back(static_cast<Device *>(*devices++));
     }
-
-    platform->mContexts.emplace_back(new Context(*platform, std::move(propArray),
-                                                 std::move(refDevices), notify, userData, userSync,
-                                                 errcodeRet));
-    if (!platform->mContexts.back()->mImpl)
-    {
-        platform->mContexts.back()->release();
-        return nullptr;
-    }
-    return platform->mContexts.back().get();
+    return platform->createContext(
+        new Context(*platform, std::move(propArray), std::move(refDevices), notify, userData,
+                    userSync, errcodeRet),
+        errcodeRet);
 }
 
 cl_context Platform::CreateContextFromType(const cl_context_properties *properties,
@@ -222,15 +219,9 @@ cl_context Platform::CreateContextFromType(const cl_context_properties *properti
     bool userSync                = false;
     Context::PropArray propArray = ParseContextProperties(properties, platform, userSync);
     ASSERT(platform != nullptr);
-
-    platform->mContexts.emplace_back(new Context(*platform, std::move(propArray), deviceType,
-                                                 notify, userData, userSync, errcodeRet));
-    if (!platform->mContexts.back()->mImpl || platform->mContexts.back()->mDevices.empty())
-    {
-        platform->mContexts.back()->release();
-        return nullptr;
-    }
-    return platform->mContexts.back().get();
+    return platform->createContext(new Context(*platform, std::move(propArray), deviceType, notify,
+                                               userData, userSync, errcodeRet),
+                                   errcodeRet);
 }
 
 Platform::Platform(const cl_icd_dispatch &dispatch, const CreateImplFunc &createImplFunc)
@@ -240,6 +231,21 @@ Platform::Platform(const cl_icd_dispatch &dispatch, const CreateImplFunc &create
       mDevices(mImpl->createDevices(*this))
 {}
 
+cl_context Platform::createContext(Context *context, cl_int *errcodeRet)
+{
+    mContexts.emplace_back(context);
+    if (!mContexts.back()->mImpl)
+    {
+        mContexts.back()->release();
+        return nullptr;
+    }
+    if (errcodeRet != nullptr)
+    {
+        *errcodeRet = CL_SUCCESS;
+    }
+    return mContexts.back().get();
+}
+
 void Platform::destroyContext(Context *context)
 {
     auto contextIt = mContexts.cbegin();

src/libANGLE/CLPlatform.h

@@ -37,7 +37,7 @@ class Platform final : public _cl_platform_id, public Object
     bool hasCommandQueue(const _cl_command_queue *commandQueue) const;
     bool hasMemory(const _cl_mem *memory) const;
 
-    cl_int getInfo(PlatformInfo name, size_t valueSize, void *value, size_t *valueSizeRet);
+    cl_int getInfo(PlatformInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
 
     cl_int getDeviceIDs(cl_device_type deviceType,
                         cl_uint numEntries,
@@ -75,6 +75,7 @@ class Platform final : public _cl_platform_id, public Object
   private:
     Platform(const cl_icd_dispatch &dispatch, const CreateImplFunc &createImplFunc);
 
+    cl_context createContext(Context *context, cl_int *errcodeRet);
     void destroyContext(Context *context);
 
     static PtrList &GetList();

src/libANGLE/CLtypes.h

@@ -28,6 +28,7 @@ class CommandQueue;
 class Context;
 class Device;
 class Event;
+class Image;
 class Kernel;
 class Memory;
 class Object;
@@ -53,6 +54,19 @@ using MemoryRefPtr  = RefPointer<Memory>;
 using DevicePtrList = std::list<DevicePtr>;
 using DeviceRefList = std::vector<DeviceRefPtr>;
 
+struct ImageDescriptor
+{
+    cl_mem_object_type type;
+    size_t width;
+    size_t height;
+    size_t depth;
+    size_t arraySize;
+    size_t rowPitch;
+    size_t slicePitch;
+    cl_uint numMipLevels;
+    cl_uint numSamples;
+};
+
 }  // namespace cl
 
 #endif  // LIBANGLE_CLTYPES_H_

src/libANGLE/cl_utils.cpp

+//
+// Copyright 2021 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// cl_utils.cpp: Helper functions for the CL front end
+
+#include <libANGLE/cl_utils.h>
+
+namespace cl
+{
+
+size_t GetChannelCount(cl_channel_order channelOrder)
+{
+    size_t count = 0u;
+    switch (channelOrder)
+    {
+        case CL_R:
+        case CL_A:
+        case CL_LUMINANCE:
+        case CL_INTENSITY:
+        case CL_DEPTH:
+            count = 1u;
+            break;
+        case CL_RG:
+        case CL_RA:
+        case CL_Rx:
+            count = 2u;
+            break;
+        case CL_RGB:
+        case CL_RGx:
+        case CL_sRGB:
+            count = 3u;
+            break;
+        case CL_RGBA:
+        case CL_ARGB:
+        case CL_BGRA:
+        case CL_ABGR:
+        case CL_RGBx:
+        case CL_sRGBA:
+        case CL_sBGRA:
+        case CL_sRGBx:
+            count = 4u;
+            break;
+        default:
+            break;
+    }
+    return count;
+}
+
+size_t GetElementSize(const cl_image_format &image_format)
+{
+    size_t size = 0u;
+    switch (image_format.image_channel_data_type)
+    {
+        case CL_SNORM_INT8:
+        case CL_UNORM_INT8:
+        case CL_SIGNED_INT8:
+        case CL_UNSIGNED_INT8:
+            size = GetChannelCount(image_format.image_channel_order);
+            break;
+        case CL_SNORM_INT16:
+        case CL_UNORM_INT16:
+        case CL_SIGNED_INT16:
+        case CL_UNSIGNED_INT16:
+        case CL_HALF_FLOAT:
+            size = 2u * GetChannelCount(image_format.image_channel_order);
+            break;
+        case CL_SIGNED_INT32:
+        case CL_UNSIGNED_INT32:
+        case CL_FLOAT:
+            size = 4u * GetChannelCount(image_format.image_channel_order);
+            break;
+        case CL_UNORM_SHORT_565:
+        case CL_UNORM_SHORT_555:
+            size = 2u;
+            break;
+        case CL_UNORM_INT_101010:
+        case CL_UNORM_INT_101010_2:
+            size = 4u;
+            break;
+        default:
+            break;
+    }
+    return size;
+}
+
+}  // namespace cl

src/libANGLE/cl_utils.h

+//
+// Copyright 2021 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// cl_utils.h: Helper functions for the CL front end
+
+#ifndef LIBANGLE_CL_UTILS_H_
+#define LIBANGLE_CL_UTILS_H_
+
+#include "libANGLE/CLtypes.h"
+
+namespace cl
+{
+
+size_t GetChannelCount(cl_channel_order channelOrder);
+
+size_t GetElementSize(const cl_image_format &image_format);
+
+}  // namespace cl
+
+#endif  // LIBANGLE_CL_UTILS_H_

src/libANGLE/renderer/CLContextImpl.h

@@ -27,10 +27,17 @@ class CLContextImpl : angle::NonCopyable
 
     virtual CLCommandQueueImpl::Ptr createCommandQueue(const cl::CommandQueue &commandQueue,
                                                        cl_int *errcodeRet) = 0;
+
     virtual CLMemoryImpl::Ptr createBuffer(const cl::Buffer &buffer,
                                            size_t size,
                                            void *hostPtr,
-                                           cl_int *errcodeRet)             = 0;
+                                           cl_int *errcodeRet) = 0;
+
+    virtual CLMemoryImpl::Ptr createImage(const cl::Image &image,
+                                          const cl_image_format &format,
+                                          const cl::ImageDescriptor &desc,
+                                          void *hostPtr,
+                                          cl_int *errcodeRet) = 0;
 
   protected:
     const cl::Context &mContext;

src/libANGLE/renderer/CLDeviceImpl.h

@@ -36,7 +36,17 @@ class CLDeviceImpl : angle::NonCopyable
         cl_device_type mType = 0u;
         std::vector<size_t> mMaxWorkItemSizes;
         cl_ulong mMaxMemAllocSize = 0u;
+        cl_bool mImageSupport     = CL_FALSE;
         NameVersionVector mILsWithVersion;
+        size_t mImage2D_MaxWidth           = 0u;
+        size_t mImage2D_MaxHeight          = 0u;
+        size_t mImage3D_MaxWidth           = 0u;
+        size_t mImage3D_MaxHeight          = 0u;
+        size_t mImage3D_MaxDepth           = 0u;
+        size_t mImageMaxBufferSize         = 0u;
+        size_t mImageMaxArraySize          = 0u;
+        cl_uint mImagePitchAlignment       = 0u;
+        cl_uint mImageBaseAddressAlignment = 0u;
         NameVersionVector mBuiltInKernelsWithVersion;
         std::string mVersionStr;
         cl_version mVersion = 0u;

src/libANGLE/renderer/cl/CLContextCL.cpp

@@ -15,6 +15,7 @@
 #include "libANGLE/CLCommandQueue.h"
 #include "libANGLE/CLContext.h"
 #include "libANGLE/CLDevice.h"
+#include "libANGLE/CLImage.h"
 #include "libANGLE/CLMemory.h"
 #include "libANGLE/CLPlatform.h"
 #include "libANGLE/Debug.h"
@@ -117,4 +118,56 @@ CLMemoryImpl::Ptr CLContextCL::createBuffer(const cl::Buffer &buffer,
                                                      : nullptr);
 }
 
+CLMemoryImpl::Ptr CLContextCL::createImage(const cl::Image &image,
+                                           const cl_image_format &format,
+                                           const cl::ImageDescriptor &desc,
+                                           void *hostPtr,
+                                           cl_int *errcodeRet)
+{
+    cl_mem nativeImage = nullptr;
+
+    if (mContext.getPlatform().isVersionOrNewer(1u, 2u))
+    {
+        const cl_image_desc nativeDesc = {
+            desc.type,       desc.width,
+            desc.height,     desc.depth,
+            desc.arraySize,  desc.rowPitch,
+            desc.slicePitch, desc.numMipLevels,
+            desc.numSamples, {static_cast<cl_mem>(image.getParent().get())}};
+
+        if (image.getProperties().empty())
+        {
+            nativeImage = mNative->getDispatch().clCreateImage(mNative, image.getFlags(), &format,
+                                                               &nativeDesc, hostPtr, errcodeRet);
+        }
+        else
+        {
+            nativeImage = mNative->getDispatch().clCreateImageWithProperties(
+                mNative, image.getProperties().data(), image.getFlags(), &format, &nativeDesc,
+                hostPtr, errcodeRet);
+        }
+    }
+    else
+    {
+        switch (desc.type)
+        {
+            case CL_MEM_OBJECT_IMAGE2D:
+                nativeImage = mNative->getDispatch().clCreateImage2D(
+                    mNative, image.getFlags(), &format, desc.width, desc.height, desc.rowPitch,
+                    hostPtr, errcodeRet);
+                break;
+            case CL_MEM_OBJECT_IMAGE3D:
+                nativeImage = mNative->getDispatch().clCreateImage3D(
+                    mNative, image.getFlags(), &format, desc.width, desc.height, desc.depth,
+                    desc.rowPitch, desc.slicePitch, hostPtr, errcodeRet);
+                break;
+            default:
+                ERR() << "Failed to create unsupported image type";
+                break;
+        }
+    }
+
+    return CLMemoryImpl::Ptr(nativeImage != nullptr ? new CLMemoryCL(image, nativeImage) : nullptr);
+}
+
 }  // namespace rx

src/libANGLE/renderer/cl/CLContextCL.h

@@ -25,11 +25,18 @@ class CLContextCL : public CLContextImpl
 
     CLCommandQueueImpl::Ptr createCommandQueue(const cl::CommandQueue &commandQueue,
                                                cl_int *errcodeRet) override;
+
     CLMemoryImpl::Ptr createBuffer(const cl::Buffer &buffer,
                                    size_t size,
                                    void *hostPtr,
                                    cl_int *errcodeRet) override;
 
+    CLMemoryImpl::Ptr createImage(const cl::Image &image,
+                                  const cl_image_format &format,
+                                  const cl::ImageDescriptor &desc,
+                                  void *hostPtr,
+                                  cl_int *errcodeRet) override;
+
   private:
     const cl_context mNative;
 };

src/libANGLE/renderer/cl/CLDeviceCL.cpp

@@ -85,7 +85,13 @@ CLDeviceImpl::Info CLDeviceCL::createInfo(cl_device_type type) const
         return Info{};
     }
 
-    if (!GetDeviceInfo(mNative, cl::DeviceInfo::MaxMemAllocSize, info.mMaxMemAllocSize))
+    if (!GetDeviceInfo(mNative, cl::DeviceInfo::MaxMemAllocSize, info.mMaxMemAllocSize) ||
+        !GetDeviceInfo(mNative, cl::DeviceInfo::ImageSupport, info.mImageSupport) ||
+        !GetDeviceInfo(mNative, cl::DeviceInfo::Image2D_MaxWidth, info.mImage2D_MaxWidth) ||
+        !GetDeviceInfo(mNative, cl::DeviceInfo::Image2D_MaxHeight, info.mImage2D_MaxHeight) ||
+        !GetDeviceInfo(mNative, cl::DeviceInfo::Image3D_MaxWidth, info.mImage3D_MaxWidth) ||
+        !GetDeviceInfo(mNative, cl::DeviceInfo::Image3D_MaxHeight, info.mImage3D_MaxHeight) ||
+        !GetDeviceInfo(mNative, cl::DeviceInfo::Image3D_MaxDepth, info.mImage3D_MaxDepth))
     {
         return Info{};
     }
@@ -109,12 +115,22 @@ CLDeviceImpl::Info CLDeviceCL::createInfo(cl_device_type type) const
     RemoveUnsupportedCLExtensions(info.mExtensions);
 
     if (info.mVersion >= CL_MAKE_VERSION(1, 2, 0) &&
-        (!GetDeviceInfo(mNative, cl::DeviceInfo::PartitionProperties, info.mPartitionProperties) ||
+        (!GetDeviceInfo(mNative, cl::DeviceInfo::ImageMaxBufferSize, info.mImageMaxBufferSize) ||
+         !GetDeviceInfo(mNative, cl::DeviceInfo::ImageMaxArraySize, info.mImageMaxArraySize) ||
+         !GetDeviceInfo(mNative, cl::DeviceInfo::PartitionProperties, info.mPartitionProperties) ||
          !GetDeviceInfo(mNative, cl::DeviceInfo::PartitionType, info.mPartitionType)))
     {
         return Info{};
     }
 
+    if (info.mVersion >= CL_MAKE_VERSION(2, 0, 0) &&
+        (!GetDeviceInfo(mNative, cl::DeviceInfo::ImagePitchAlignment, info.mImagePitchAlignment) ||
+         !GetDeviceInfo(mNative, cl::DeviceInfo::ImageBaseAddressAlignment,
+                        info.mImageBaseAddressAlignment)))
+    {
+        return Info{};
+    }
+
     if (info.mVersion >= CL_MAKE_VERSION(3, 0, 0) &&
         (!GetDeviceInfo(mNative, cl::DeviceInfo::ILsWithVersion, info.mILsWithVersion) ||
          !GetDeviceInfo(mNative, cl::DeviceInfo::BuiltInKernelsWithVersion,

src/libANGLE/renderer/cl/CLPlatformCL.cpp

@@ -222,7 +222,7 @@ CLPlatformImpl::Info CLPlatformCL::createInfo() const
          mNative->getDispatch().clEnqueueCopyBufferRect == nullptr))
     {
         ERR() << "Missing entry points for OpenCL 1.1";
-        return info;
+        return Info{};
     }
 
     if (info.mVersion >= CL_MAKE_VERSION(1, 2, 0) &&
@@ -243,7 +243,7 @@ CLPlatformImpl::Info CLPlatformCL::createInfo() const
          mNative->getDispatch().clGetExtensionFunctionAddressForPlatform == nullptr))
     {
         ERR() << "Missing entry points for OpenCL 1.2";
-        return info;
+        return Info{};
     }
 
     if (info.mVersion >= CL_MAKE_VERSION(2, 0, 0) &&
@@ -262,7 +262,7 @@ CLPlatformImpl::Info CLPlatformCL::createInfo() const
          mNative->getDispatch().clSetKernelExecInfo == nullptr))
     {
         ERR() << "Missing entry points for OpenCL 2.0";
-        return info;
+        return Info{};
     }
 
     if (info.mVersion >= CL_MAKE_VERSION(2, 1, 0) &&
@@ -275,7 +275,7 @@ CLPlatformImpl::Info CLPlatformCL::createInfo() const
          mNative->getDispatch().clSetDefaultDeviceCommandQueue == nullptr))
     {
         ERR() << "Missing entry points for OpenCL 2.1";
-        return info;
+        return Info{};
     }
 
     if (info.mVersion >= CL_MAKE_VERSION(2, 2, 0) &&
@@ -283,7 +283,7 @@ CLPlatformImpl::Info CLPlatformCL::createInfo() const
          mNative->getDispatch().clSetProgramSpecializationConstant == nullptr))
     {
         ERR() << "Missing entry points for OpenCL 2.2";
-        return info;
+        return Info{};
     }
 
     if (info.mVersion >= CL_MAKE_VERSION(3, 0, 0) &&
@@ -292,7 +292,7 @@ CLPlatformImpl::Info CLPlatformCL::createInfo() const
          mNative->getDispatch().clSetContextDestructorCallback == nullptr))
     {
         ERR() << "Missing entry points for OpenCL 3.0";
-        return info;
+        return Info{};
     }
 
     return info;

src/libANGLE/validationCL.h

@@ -14,6 +14,7 @@
 #include "libANGLE/CLContext.h"
 #include "libANGLE/CLDevice.h"
 #include "libANGLE/CLEvent.h"
+#include "libANGLE/CLImage.h"
 #include "libANGLE/CLKernel.h"
 #include "libANGLE/CLMemory.h"
 #include "libANGLE/CLPlatform.h"

src/libGLESv2.gni

@@ -458,6 +458,7 @@ libangle_cl_headers = [
   "src/libANGLE/CLContext.h",
   "src/libANGLE/CLDevice.h",
   "src/libANGLE/CLEvent.h",
+  "src/libANGLE/CLImage.h",
   "src/libANGLE/CLKernel.h",
   "src/libANGLE/CLMemory.h",
   "src/libANGLE/CLObject.h",
@@ -466,6 +467,7 @@ libangle_cl_headers = [
   "src/libANGLE/CLRefPointer.h",
   "src/libANGLE/CLSampler.h",
   "src/libANGLE/CLtypes.h",
+  "src/libANGLE/cl_utils.h",
   "src/libANGLE/renderer/CLCommandQueueImpl.h",
   "src/libANGLE/renderer/CLContextImpl.h",
   "src/libANGLE/renderer/CLDeviceImpl.h",
@@ -482,12 +484,14 @@ libangle_cl_sources = [
   "src/libANGLE/CLContext.cpp",
   "src/libANGLE/CLDevice.cpp",
   "src/libANGLE/CLEvent.cpp",
+  "src/libANGLE/CLImage.cpp",
   "src/libANGLE/CLKernel.cpp",
   "src/libANGLE/CLMemory.cpp",
   "src/libANGLE/CLObject.cpp",
   "src/libANGLE/CLPlatform.cpp",
   "src/libANGLE/CLProgram.cpp",
   "src/libANGLE/CLSampler.cpp",
+  "src/libANGLE/cl_utils.cpp",
   "src/libANGLE/renderer/CLCommandQueueImpl.cpp",
   "src/libANGLE/renderer/CLContextImpl.cpp",
   "src/libANGLE/renderer/CLDeviceImpl.cpp",

src/libGLESv2/cl_stubs.cpp

@@ -13,6 +13,7 @@
 #include "libANGLE/CLCommandQueue.h"
 #include "libANGLE/CLContext.h"
 #include "libANGLE/CLDevice.h"
+#include "libANGLE/CLImage.h"
 #include "libANGLE/CLMemory.h"
 #include "libANGLE/CLPlatform.h"
 
@@ -241,8 +242,8 @@ cl_mem CreateImage(cl_context context,
                    void *host_ptr,
                    cl_int *errcode_ret)
 {
-    WARN_NOT_SUPPORTED(CreateImage);
-    return 0;
+    return static_cast<Context *>(context)->createImage(nullptr, flags, image_format, image_desc,
+                                                        host_ptr, errcode_ret);
 }
 
 cl_mem CreateImageWithProperties(cl_context context,
@@ -253,8 +254,8 @@ cl_mem CreateImageWithProperties(cl_context context,
                                  void *host_ptr,
                                  cl_int *errcode_ret)
 {
-    WARN_NOT_SUPPORTED(CreateImageWithProperties);
-    return 0;
+    return static_cast<Context *>(context)->createImage(properties, flags, image_format, image_desc,
+                                                        host_ptr, errcode_ret);
 }
 
 cl_mem CreatePipe(cl_context context,
@@ -307,8 +308,8 @@ cl_int GetImageInfo(cl_mem image,
                     void *param_value,
                     size_t *param_value_size_ret)
 {
-    WARN_NOT_SUPPORTED(GetImageInfo);
-    return 0;
+    return static_cast<Image *>(image)->getInfo(param_name, param_value_size, param_value,
+                                                param_value_size_ret);
 }
 
 cl_int GetPipeInfo(cl_mem pipe,
@@ -1080,8 +1081,8 @@ cl_mem CreateImage2D(cl_context context,
                      void *host_ptr,
                      cl_int *errcode_ret)
 {
-    WARN_NOT_SUPPORTED(CreateImage2D);
-    return 0;
+    return static_cast<Context *>(context)->createImage2D(
+        flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
 }
 
 cl_mem CreateImage3D(cl_context context,
@@ -1095,8 +1096,9 @@ cl_mem CreateImage3D(cl_context context,
                      void *host_ptr,
                      cl_int *errcode_ret)
 {
-    WARN_NOT_SUPPORTED(CreateImage3D);
-    return 0;
+    return static_cast<Context *>(context)->createImage3D(
+        flags, image_format, image_width, image_height, image_depth, image_row_pitch,
+        image_slice_pitch, host_ptr, errcode_ret);
 }
 
 cl_int EnqueueMarker(cl_command_queue command_queue, cl_event *event)