lamino-filters/src/ufo-filter-scale.c

#include <gmodule.h>
#ifdef __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif

#include <ufo/ufo-filter.h>
#include <ufo/ufo-buffer.h>
#include <ufo/ufo-resource-manager.h>

#include "ufo-filter-scale.h"

/**
 * SECTION:ufo-filter-scale
 * @Short_description: Scale image values 
 * @Title: scale
 *
 * Scale input image values. The output
 * is a new image. 
 * #UfoFilterScale: params.
*/

struct _UfoFilterScalePrivate {
    float scale;
    cl_kernel kernel;
};

GType ufo_filter_scale_get_type(void) G_GNUC_CONST;

G_DEFINE_TYPE(UfoFilterScale, ufo_filter_scale, UFO_TYPE_FILTER);

#define UFO_FILTER_SCALE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UFO_TYPE_FILTER_SCALE, UfoFilterScalePrivate))

enum {
    PROP_0 =0,
    PROP_SCALE,
    N_PROPERTIES
};

static GParamSpec *scale_properties[N_PROPERTIES] = { NULL, };


/* 
 * virtual methods 
 */
static void 
ufo_filter_scale_initialize(UfoFilter *filter, UfoBuffer *params[], guint **dim_sizes, GError **error)
{
    UfoFilterScalePrivate *priv = UFO_FILTER_SCALE_GET_PRIVATE(filter);
    UfoResourceManager *manager = ufo_filter_get_resource_manager(filter);
    GError *tmp_error = NULL;

    priv->kernel = ufo_resource_manager_get_kernel(manager, "scale.cl", "scale", &tmp_error);
    if (tmp_error != NULL) {
	g_propagate_error (error, tmp_error);
        return;
    }
   
    guint xs, ys; 
    ufo_buffer_get_2d_dimensions (params[0], &xs, &ys);
    dim_sizes[0][0] = xs;
    dim_sizes[0][1] = ys;
}

/*
 * This is the main method in which the filter processes one buffer after
 * another.
 */
static void ufo_filter_scale_process_gpu(UfoFilter *filter, UfoBuffer *input[], UfoBuffer *output[], GError **error)
{
    g_return_if_fail(UFO_IS_FILTER(filter));
    cl_command_queue command_queue = (cl_command_queue) ufo_filter_get_command_queue(filter);
    UfoFilterScalePrivate *priv = UFO_FILTER_SCALE_GET_PRIVATE(filter);

    guint xs, ys;
    ufo_buffer_get_2d_dimensions (input[0], &xs, &ys);
    size_t global_work_size[2] = {(size_t) xs, (size_t) ys};


     cl_mem input_mem  = (cl_mem) ufo_buffer_get_device_array(input[0],  command_queue);
     cl_mem output_mem = (cl_mem) ufo_buffer_get_device_array(output[0], command_queue);

     float scale = (float) priv->scale;
     cl_kernel kernel = priv->kernel;

     CHECK_OPENCL_ERROR(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *) &input_mem));
     CHECK_OPENCL_ERROR(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *) &output_mem));
     CHECK_OPENCL_ERROR(clSetKernelArg(kernel, 2, sizeof(int),   &xs));
     CHECK_OPENCL_ERROR(clSetKernelArg(kernel, 3, sizeof(float), &scale));

     cl_event event;	 
     CHECK_OPENCL_ERROR(clEnqueueNDRangeKernel(command_queue, kernel,
					      2, NULL, global_work_size, NULL,
					      0, NULL, &event));
     clFinish(command_queue);	 
}

static void 
ufo_filter_scale_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
    UfoFilterScale *self = UFO_FILTER_SCALE(object);

    switch (property_id) {
        case PROP_SCALE:
            self->priv->scale = (float) g_value_get_double(value);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
            break;
    }
}

static void 
ufo_filter_scale_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
{
    UfoFilterScale *self = UFO_FILTER_SCALE(object);

    switch (property_id) {
        case PROP_SCALE:
            g_value_set_double(value, (double) self->priv->scale);
            break;
        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
            break;
    }
}

static void 
ufo_filter_scale_class_init(UfoFilterScaleClass *klass)
{
    GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
    UfoFilterClass *filter_class = UFO_FILTER_CLASS(klass);

    gobject_class->set_property = ufo_filter_scale_set_property;
    gobject_class->get_property = ufo_filter_scale_get_property;
    filter_class->initialize = ufo_filter_scale_initialize;
    filter_class->process_gpu = ufo_filter_scale_process_gpu;

    scale_properties[PROP_SCALE] = 
      g_param_spec_double("scale",
        "Scale",
        "Scale for each pixel",
        -5.0,   /* minimum */
         10.0,   /* maximum */
         1.0,   /* default */
        G_PARAM_READWRITE);

    g_object_class_install_property(gobject_class, PROP_SCALE, scale_properties[PROP_SCALE]);

    /* install private data */
    g_type_class_add_private(gobject_class, sizeof(UfoFilterScalePrivate));
}

static void 
ufo_filter_scale_init(UfoFilterScale *self)
{
    UfoFilterScalePrivate *priv = self->priv = UFO_FILTER_SCALE_GET_PRIVATE(self);
    UfoInputParameter input_params[] = {{2, UFO_FILTER_INFINITE_INPUT}};
    UfoOutputParameter output_params[] = {{2}};

    priv->scale = 1.0;
    priv->kernel = NULL;
    
    ufo_filter_register_inputs (UFO_FILTER(self), 1, input_params);
    ufo_filter_register_outputs(UFO_FILTER(self), 1, output_params);
}

G_MODULE_EXPORT UfoFilter  *ufo_filter_plugin_new(void) 
{
    return g_object_new(UFO_TYPE_FILTER_SCALE, NULL);
}