QtQuickCL - Write kernels, not boilerplate

QtQuickCL is a research module for Qt 5 that enables easily creating Qt Quick
items that execute OpenCL kernels and use OpenGL resources as their input or
output. The functionality is minimal but powerful.

For example, a Qt Quick item executing an OpenCL kernel on a texture provider,
meaning an Image element or even an entire sub-tree of the Qt Quick scene, and
rendering the resulting OpenGL texture gets reduced to the following:

    static const char *openclSrc =
            "__kernel void Kernel(__read_only image2d_t imgIn, __write_only image2d_t imgOut) {\n"
            ...

    class CLRunnable : public QQuickCLImageRunnable
    {
    public:
        CLRunnable(QQuickCLItem *item)
            : QQuickCLImageRunnable(item)
        {
            m_clProgram = item->buildProgram(openclSrc);
            m_clKernel = clCreateKernel(m_clProgram, "Kernel", 0);
        }

        ~CLRunnable() {
            clReleaseKernel(m_clKernel);
            clReleaseProgram(m_clProgram);
        }

        void runKernel(cl_mem inImage, cl_mem outImage, const QSize &size) Q_DECL_OVERRIDE {
            clSetKernelArg(m_clKernel, 0, sizeof(cl_mem), &inImage);
            clSetKernelArg(m_clKernel, 1, sizeof(cl_mem), &outImage);
            const size_t workSize[] = { size_t(size.width()), size_t(size.height()) };
            clEnqueueNDRangeKernel(commandQueue(), m_clKernel, 2, 0, workSize, 0, 0, 0, 0);
        }

    private:
        cl_program m_clProgram;
        cl_kernel m_clKernel;
    };

    class CLItem : public QQuickCLItem
    {
        Q_OBJECT
        Q_PROPERTY(QQuickItem *source READ source WRITE setSource)

    public:
        CLItem() : m_source(0) { }

        QQuickCLRunnable *createCL() Q_DECL_OVERRIDE { return new CLRunnable(this); }

        QQuickItem *source() const { return m_source; }
        void setSource(QQuickItem *source) { m_source = source; update(); }

    private:
        QQuickItem *m_source;
    };

All the CL-GL interop, including the selection of the correct CL platform and
device, is taken care of by the module. The QQuickCLItem - QQuickCLRunnable
split ensures easy and safe CL and GL resource management even when threaded
rendering is in use.

Besides the minimal and lightweight framework, examples are provided for the
following common use cases:

   * GL texture -> GL texture (image processing, i.e. ShaderEffect but with CL)

   * GL texture -> arbitrary data that gets visualized through Qt Quick
     (f.ex. histogram)

   * Non-GL data -> GL buffer with vertex data which is used in OpenGL rendering
     without any additional readbacks or copies (e.g. particle simulation)

The intention for these is not merely to test and demo the classes, but to serve
as a reference for integrating Qt Quick and OpenCL and to help getting started
with CL development.