int process_cl(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out) { dt_iop_colisa_data_t *d = (dt_iop_colisa_data_t *)piece->data; dt_iop_colisa_global_data_t *gd = (dt_iop_colisa_global_data_t *)self->data; cl_int err = -999; const int devid = piece->pipe->devid; const int width = roi_in->width; const int height = roi_in->height; const float saturation = d->saturation; cl_mem dev_cm = NULL; cl_mem dev_ccoeffs = NULL; cl_mem dev_lm = NULL; cl_mem dev_lcoeffs = NULL; dev_cm = dt_opencl_copy_host_to_device(devid, d->ctable, 256, 256, sizeof(float)); if(dev_cm == NULL) goto error; dev_ccoeffs = dt_opencl_copy_host_to_device_constant(devid, sizeof(float) * 3, d->cunbounded_coeffs); if(dev_ccoeffs == NULL) goto error; dev_lm = dt_opencl_copy_host_to_device(devid, d->ltable, 256, 256, sizeof(float)); if(dev_lm == NULL) goto error; dev_lcoeffs = dt_opencl_copy_host_to_device_constant(devid, sizeof(float) * 3, d->lunbounded_coeffs); if(dev_lcoeffs == NULL) goto error; size_t sizes[3]; sizes[0] = ROUNDUPWD(width); sizes[1] = ROUNDUPWD(height); sizes[2] = 1; dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 0, sizeof(cl_mem), (void *)&dev_in); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 1, sizeof(cl_mem), (void *)&dev_out); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 2, sizeof(int), (void *)&width); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 3, sizeof(int), (void *)&height); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 4, sizeof(float), (void *)&saturation); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 5, sizeof(cl_mem), (void *)&dev_cm); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 6, sizeof(cl_mem), (void *)&dev_ccoeffs); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 7, sizeof(cl_mem), (void *)&dev_lm); dt_opencl_set_kernel_arg(devid, gd->kernel_colisa, 8, sizeof(cl_mem), (void *)&dev_lcoeffs); err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_colisa, sizes); if(err != CL_SUCCESS) goto error; if(dev_lcoeffs != NULL) dt_opencl_release_mem_object(dev_lcoeffs); if(dev_lm != NULL) dt_opencl_release_mem_object(dev_lm); if(dev_ccoeffs != NULL) dt_opencl_release_mem_object(dev_ccoeffs); if(dev_cm != NULL) dt_opencl_release_mem_object(dev_cm); return TRUE; error: if(dev_lcoeffs != NULL) dt_opencl_release_mem_object(dev_lcoeffs); if(dev_lm != NULL) dt_opencl_release_mem_object(dev_lm); if(dev_ccoeffs != NULL) dt_opencl_release_mem_object(dev_ccoeffs); if(dev_cm != NULL) dt_opencl_release_mem_object(dev_cm); dt_print(DT_DEBUG_OPENCL, "[opencl_colisa] couldn't enqueue kernel! %d\n", err); return FALSE; }
int process_cl(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out) { dt_iop_colorout_data_t *d = (dt_iop_colorout_data_t *)piece->data; dt_iop_colorout_global_data_t *gd = (dt_iop_colorout_global_data_t *)self->data; cl_mem dev_m = NULL, dev_r = NULL, dev_g = NULL, dev_b = NULL, dev_coeffs = NULL; cl_int err = -999; const int devid = piece->pipe->devid; const int width = roi_in->width; const int height = roi_in->height; size_t sizes[] = { ROUNDUPWD(width), ROUNDUPHT(height), 1 }; dev_m = dt_opencl_copy_host_to_device_constant(devid, sizeof(float) * 9, d->cmatrix); if(dev_m == NULL) goto error; dev_r = dt_opencl_copy_host_to_device(devid, d->lut[0], 256, 256, sizeof(float)); if(dev_r == NULL) goto error; dev_g = dt_opencl_copy_host_to_device(devid, d->lut[1], 256, 256, sizeof(float)); if(dev_g == NULL) goto error; dev_b = dt_opencl_copy_host_to_device(devid, d->lut[2], 256, 256, sizeof(float)); if(dev_b == NULL) goto error; dev_coeffs = dt_opencl_copy_host_to_device_constant(devid, sizeof(float) * 3 * 3, (float *)d->unbounded_coeffs); if(dev_coeffs == NULL) goto error; dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 0, sizeof(cl_mem), (void *)&dev_in); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 1, sizeof(cl_mem), (void *)&dev_out); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 2, sizeof(int), (void *)&width); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 3, sizeof(int), (void *)&height); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 4, sizeof(cl_mem), (void *)&dev_m); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 5, sizeof(cl_mem), (void *)&dev_r); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 6, sizeof(cl_mem), (void *)&dev_g); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 7, sizeof(cl_mem), (void *)&dev_b); dt_opencl_set_kernel_arg(devid, gd->kernel_colorout, 8, sizeof(cl_mem), (void *)&dev_coeffs); err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_colorout, sizes); if(err != CL_SUCCESS) goto error; dt_opencl_release_mem_object(dev_m); dt_opencl_release_mem_object(dev_r); dt_opencl_release_mem_object(dev_g); dt_opencl_release_mem_object(dev_b); dt_opencl_release_mem_object(dev_coeffs); return TRUE; error: if(dev_m != NULL) dt_opencl_release_mem_object(dev_m); if(dev_r != NULL) dt_opencl_release_mem_object(dev_r); if(dev_g != NULL) dt_opencl_release_mem_object(dev_g); if(dev_b != NULL) dt_opencl_release_mem_object(dev_b); if(dev_coeffs != NULL) dt_opencl_release_mem_object(dev_coeffs); dt_print(DT_DEBUG_OPENCL, "[opencl_colorout] couldn't enqueue kernel! %d\n", err); return FALSE; }
int process_cl (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out) { dt_iop_tonecurve_data_t *d = (dt_iop_tonecurve_data_t *)piece->data; dt_iop_tonecurve_global_data_t *gd = (dt_iop_tonecurve_global_data_t *)self->data; cl_mem dev_L, dev_a, dev_b = NULL; cl_mem dev_coeffs = NULL; cl_int err = -999; const int devid = piece->pipe->devid; const int width = roi_in->width; const int height = roi_in->height; const int autoscale_ab = d->autoscale_ab; size_t sizes[] = { ROUNDUPWD(width), ROUNDUPHT(height), 1}; dev_L = dt_opencl_copy_host_to_device(devid, d->table[ch_L], 256, 256, sizeof(float)); dev_a = dt_opencl_copy_host_to_device(devid, d->table[ch_a], 256, 256, sizeof(float)); dev_b = dt_opencl_copy_host_to_device(devid, d->table[ch_b], 256, 256, sizeof(float)); if (dev_L == NULL || dev_a == NULL || dev_b == NULL) goto error; dev_coeffs = dt_opencl_copy_host_to_device_constant(devid, sizeof(float)*3, d->unbounded_coeffs); if (dev_coeffs == NULL) goto error; dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 0, sizeof(cl_mem), (void *)&dev_in); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 1, sizeof(cl_mem), (void *)&dev_out); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 2, sizeof(int), (void *)&width); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 3, sizeof(int), (void *)&height); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 4, sizeof(cl_mem), (void *)&dev_L); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 5, sizeof(cl_mem), (void *)&dev_a); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 6, sizeof(cl_mem), (void *)&dev_b); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 7, sizeof(int), (void *)&autoscale_ab); dt_opencl_set_kernel_arg(devid, gd->kernel_tonecurve, 8, sizeof(cl_mem), (void *)&dev_coeffs); err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_tonecurve, sizes); if(err != CL_SUCCESS) goto error; dt_opencl_release_mem_object(dev_L); dt_opencl_release_mem_object(dev_a); dt_opencl_release_mem_object(dev_b); dt_opencl_release_mem_object(dev_coeffs); return TRUE; error: if (dev_L != NULL) dt_opencl_release_mem_object(dev_L); if (dev_a != NULL) dt_opencl_release_mem_object(dev_a); if (dev_b != NULL) dt_opencl_release_mem_object(dev_b); if (dev_coeffs != NULL) dt_opencl_release_mem_object(dev_coeffs); dt_print(DT_DEBUG_OPENCL, "[opencl_tonecurve] couldn't enqueue kernel! %d\n", err); return FALSE; }
int process_cl(dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out) { dt_iop_levels_data_t *d = (dt_iop_levels_data_t *)piece->data; dt_iop_levels_global_data_t *gd = (dt_iop_levels_global_data_t *)self->data; if(d->mode == LEVELS_MODE_AUTOMATIC) { commit_params_late(self, piece); } cl_mem dev_lut = NULL; cl_int err = -999; const int devid = piece->pipe->devid; const int width = roi_out->width; const int height = roi_out->height; dev_lut = dt_opencl_copy_host_to_device(devid, d->lut, 256, 256, sizeof(float)); if(dev_lut == NULL) goto error; size_t sizes[2] = { ROUNDUPWD(width), ROUNDUPHT(height) }; dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 0, sizeof(cl_mem), &dev_in); dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 1, sizeof(cl_mem), &dev_out); dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 2, sizeof(int), &width); dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 3, sizeof(int), &height); dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 4, sizeof(cl_mem), &dev_lut); dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 5, sizeof(float), &d->levels[0]); dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 6, sizeof(float), &d->levels[2]); dt_opencl_set_kernel_arg(devid, gd->kernel_levels, 7, sizeof(float), &d->in_inv_gamma); err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_levels, sizes); if(err != CL_SUCCESS) goto error; dt_opencl_release_mem_object(dev_lut); return TRUE; error: if(dev_lut != NULL) dt_opencl_release_mem_object(dev_lut); dt_print(DT_DEBUG_OPENCL, "[opencl_levels] couldn't enqueue kernel! %d\n", err); return FALSE; }
int process_cl(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out) { dt_iop_lowlight_data_t *d = (dt_iop_lowlight_data_t *)piece->data; dt_iop_lowlight_global_data_t *gd = (dt_iop_lowlight_global_data_t *)self->data; cl_mem dev_m = NULL; cl_int err = -999; const int devid = piece->pipe->devid; const int width = roi_out->width; const int height = roi_out->height; // scotopic white, blue saturated float Lab_sw[3] = { 100.0f, 0.0f, -d->blueness }; float XYZ_sw[4]; dt_Lab_to_XYZ(Lab_sw, XYZ_sw); dev_m = dt_opencl_copy_host_to_device(devid, d->lut, 256, 256, sizeof(float)); if(dev_m == NULL) goto error; size_t sizes[2] = { ROUNDUPWD(width), ROUNDUPHT(height) }; dt_opencl_set_kernel_arg(devid, gd->kernel_lowlight, 0, sizeof(cl_mem), &dev_in); dt_opencl_set_kernel_arg(devid, gd->kernel_lowlight, 1, sizeof(cl_mem), &dev_out); dt_opencl_set_kernel_arg(devid, gd->kernel_lowlight, 2, sizeof(int), &width); dt_opencl_set_kernel_arg(devid, gd->kernel_lowlight, 3, sizeof(int), &height); dt_opencl_set_kernel_arg(devid, gd->kernel_lowlight, 4, 4 * sizeof(float), &XYZ_sw); dt_opencl_set_kernel_arg(devid, gd->kernel_lowlight, 5, sizeof(cl_mem), &dev_m); err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_lowlight, sizes); if(err != CL_SUCCESS) goto error; dt_opencl_release_mem_object(dev_m); return TRUE; error: dt_opencl_release_mem_object(dev_m); dt_print(DT_DEBUG_OPENCL, "[opencl_lowlight] couldn't enqueue kernel! %d\n", err); return FALSE; }
int process_cl (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out) { dt_iop_lowpass_data_t *d = (dt_iop_lowpass_data_t *)piece->data; dt_iop_lowpass_global_data_t *gd = (dt_iop_lowpass_global_data_t *)self->data; cl_int err = -999; const int devid = piece->pipe->devid; const int width = roi_in->width; const int height = roi_in->height; const int channels = piece->colors; const float Labmax[] = { 100.0f, 128.0f, 128.0f, 1.0f }; const float Labmin[] = { 0.0f, -128.0f, -128.0f, 0.0f }; const int use_bilateral = d->radius < 0 ? 1 : 0; const float radius = fmax(0.1f, fabs(d->radius)); const float sigma = radius * roi_in->scale / piece ->iscale; const float saturation = d->saturation; const int order = d->order; size_t sizes[3]; cl_mem dev_m = NULL; cl_mem dev_coeffs = NULL; dt_gaussian_cl_t *g = NULL; dt_bilateral_cl_t *b = NULL; if(!use_bilateral) { g = dt_gaussian_init_cl(devid, width, height, channels, Labmax, Labmin, sigma, order); if(!g) goto error; err = dt_gaussian_blur_cl(g, dev_in, dev_out); if(err != CL_SUCCESS) goto error; dt_gaussian_free_cl(g); g = NULL; } else { const float sigma_r = 100.0f; // does not depend on scale const float sigma_s = sigma; const float detail = -1.0f; // we want the bilateral base layer b = dt_bilateral_init_cl(devid, width, height, sigma_s, sigma_r); if(!b) goto error; err = dt_bilateral_splat_cl(b, dev_in); if (err != CL_SUCCESS) goto error; err = dt_bilateral_blur_cl(b); if (err != CL_SUCCESS) goto error; err = dt_bilateral_slice_cl(b, dev_in, dev_out, detail); if (err != CL_SUCCESS) goto error; dt_bilateral_free_cl(b); b = NULL; // make sure we don't clean it up twice } dev_m = dt_opencl_copy_host_to_device(devid, d->table, 256, 256, sizeof(float)); if(dev_m == NULL) goto error; dev_coeffs = dt_opencl_copy_host_to_device_constant(devid, sizeof(float)*3, d->unbounded_coeffs); if(dev_coeffs == NULL) goto error; sizes[0] = ROUNDUPWD(width); sizes[1] = ROUNDUPWD(height); sizes[2] = 1; dt_opencl_set_kernel_arg(devid, gd->kernel_lowpass_mix, 0, sizeof(cl_mem), (void *)&dev_out); dt_opencl_set_kernel_arg(devid, gd->kernel_lowpass_mix, 1, sizeof(cl_mem), (void *)&dev_out); dt_opencl_set_kernel_arg(devid, gd->kernel_lowpass_mix, 2, sizeof(int), (void *)&width); dt_opencl_set_kernel_arg(devid, gd->kernel_lowpass_mix, 3, sizeof(int), (void *)&height); dt_opencl_set_kernel_arg(devid, gd->kernel_lowpass_mix, 4, sizeof(float), (void *)&saturation); dt_opencl_set_kernel_arg(devid, gd->kernel_lowpass_mix, 5, sizeof(cl_mem), (void *)&dev_m); dt_opencl_set_kernel_arg(devid, gd->kernel_lowpass_mix, 6, sizeof(cl_mem), (void *)&dev_coeffs); err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_lowpass_mix, sizes); if(err != CL_SUCCESS) goto error; if (dev_coeffs != NULL) dt_opencl_release_mem_object(dev_coeffs); if (dev_m != NULL) dt_opencl_release_mem_object(dev_m); return TRUE; error: if (g) dt_gaussian_free_cl(g); if (b) dt_bilateral_free_cl(b); if (dev_coeffs != NULL) dt_opencl_release_mem_object(dev_coeffs); if (dev_m != NULL) dt_opencl_release_mem_object(dev_m); dt_print(DT_DEBUG_OPENCL, "[opencl_lowpass] couldn't enqueue kernel! %d\n", err); return FALSE; }