ccl_image_wrapper.h

Go to the documentation of this file.

/*
 * This file is part of cf4ocl (C Framework for OpenCL).
 *
 * cf4ocl 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 3 of the
 * License, or (at your option) any later version.
 *
 * cf4ocl 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 cf4ocl. If not, see
 * <http://www.gnu.org/licenses/>.
 * */

#ifndef _CCL_IMAGE_WRAPPER_H_
#define _CCL_IMAGE_WRAPPER_H_

#include "ccl_memobj_wrapper.h"

#define CCL_IMAGE_DESC_BLANK {0, 0, 0, 0, 0, 0, 0, 0, 0, NULL}

typedef struct ccl_image_desc {

    cl_mem_object_type image_type;

    size_t image_width;

    size_t image_height;

    size_t image_depth;

    size_t image_array_size;

    size_t image_row_pitch;

    size_t image_slice_pitch;

    cl_uint num_mip_levels;

    cl_uint num_samples;

    CCLMemObj* memobj;

} CCLImageDesc;

/* Get the image wrapper for the given OpenCL image. */
CCL_EXPORT
CCLImage* ccl_image_new_wrap(cl_mem mem_object);

/* Decrements the reference count of the wrapper object. If it
 * reaches 0, the wrapper object is destroyed. */
CCL_EXPORT
void ccl_image_destroy(CCLImage* img);

/* Creates a new image wrapper object. */
CCL_EXPORT
CCLImage* ccl_image_new_v(CCLContext* ctx, cl_mem_flags flags,
    const cl_image_format* image_format, const CCLImageDesc* img_dsc,
    void* host_ptr, CCLErr** err);

/* Creates a new image wrapper object using a variable list of key-value
 * pairs which describe the image.  */
CCL_EXPORT
CCLImage* ccl_image_new(CCLContext* ctx, cl_mem_flags flags,
    const cl_image_format* image_format, void* host_ptr, CCLErr** err,
    ...);

/* Read from an image or image array object to host memory. */
CCL_EXPORT
CCLEvent* ccl_image_enqueue_read(CCLImage* img, CCLQueue* cq,
    cl_bool blocking_read, const size_t* origin, const size_t* region,
    size_t row_pitch, size_t slice_pitch, void *ptr,
    CCLEventWaitList* evt_wait_lst, CCLErr** err);

/* Write to an image or image array object from host memory. */
CCL_EXPORT
CCLEvent* ccl_image_enqueue_write(CCLImage* img, CCLQueue* cq,
    cl_bool blocking_read, const size_t* origin, const size_t* region,
    size_t input_row_pitch, size_t input_slice_pitch, void *ptr,
    CCLEventWaitList* evt_wait_lst, CCLErr** err);

/* Copy image objects. This function wraps the clEnqueueCopyImage()
 * OpenCL function. */
CCL_EXPORT
CCLEvent* ccl_image_enqueue_copy(CCLImage* src_img, CCLImage* dst_img,
    CCLQueue* cq, const size_t* src_origin, const size_t* dst_origin,
    const size_t* region, CCLEventWaitList* evt_wait_lst, CCLErr** err);

/* Copy an image object to a buffer object. */
CCL_EXPORT
CCLEvent* ccl_image_enqueue_copy_to_buffer(CCLImage* src_img,
    CCLBuffer* dst_buf, CCLQueue* cq, const size_t *src_origin,
    const size_t *region, size_t dst_offset,
    CCLEventWaitList* evt_wait_lst, CCLErr** err);

/* Map a region of the image into the host address space and return a
 * pointer to this mapped region. */
CCL_EXPORT
void* ccl_image_enqueue_map(CCLImage* img, CCLQueue* cq,
    cl_bool blocking_map, cl_map_flags map_flags, const size_t* origin,
    const size_t* region, size_t *image_row_pitch,
    size_t *image_slice_pitch, CCLEventWaitList* evt_wait_lst,
    CCLEvent** evt, CCLErr** err);

/* Fill an image object with a specified color. This function wraps the
 * clEnqueueFillImage() OpenCL function. */
CCL_EXPORT
CCLEvent* ccl_image_enqueue_fill(CCLImage* img, CCLQueue* cq,
    const void *fill_color, const size_t *origin, const size_t *region,
    CCLEventWaitList* evt_wait_lst, CCLErr** err);

#define ccl_image_enqueue_unmap(img, cq, ptr, ewl, err) \
    ccl_memobj_enqueue_unmap((CCLMemObj*) img, cq, ptr, ewl, err)

#define ccl_image_get_info(img, param_name, err) \
    ccl_wrapper_get_info((CCLWrapper*) img, NULL, param_name, 0, \
        CCL_INFO_IMAGE, CL_FALSE, err)

#define ccl_image_get_info_scalar(img, param_name, param_type, err) \
    *((param_type*) ccl_wrapper_get_info_value((CCLWrapper*) img, \
        NULL, param_name, sizeof(param_type), CCL_INFO_IMAGE, CL_FALSE, err))

#define ccl_image_get_info_array(img, param_name, param_type, err) \
    (param_type) ccl_wrapper_get_info_value((CCLWrapper*) img, \
        NULL, param_name, sizeof(param_type), CCL_INFO_IMAGE, CL_FALSE, err)

#define ccl_image_ref(img) \
    ccl_wrapper_ref((CCLWrapper*) img)

#define ccl_image_unref(img) ccl_image_destroy(img)

#define ccl_image_unwrap(img) \
    ((cl_mem) ccl_wrapper_unwrap((CCLWrapper*) img))

#endif