3,012 changes: 1,552 additions & 1,460 deletions po/zh_TW.po
View file

Large diffs are not rendered by default.

9 changes: 9 additions & 0 deletions src/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -363,6 +363,15 @@ if(USE_OPENEXR)
endif(OpenEXR_FOUND)
endif(USE_OPENEXR)

if(USE_JXL)
find_package(JXL 0.7.0)
if(JXL_FOUND)
include_directories(SYSTEM ${JXL_INCLUDE_DIRS})
list(APPEND LIBS ${JXL_LIBRARIES})
add_definitions(${JXL_DEFINITIONS})
endif(JXL_FOUND)
endif(USE_JXL)

if(USE_WEBP)
find_package(WebP 0.3.0)
if(WebP_FOUND)
Expand Down
90 changes: 18 additions & 72 deletions src/common/bilateralcl.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -138,12 +138,8 @@ dt_bilateral_cl_t *dt_bilateral_init_cl(const int devid,

// zero out grid
int wd = b->size_x, ht = b->size_y * b->size_z;
size_t sizes[] = { ROUNDUPDWD(wd, b->devid), ROUNDUPDHT(ht, b->devid), 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_zero, 0, sizeof(cl_mem), (void *)&b->dev_grid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_zero, 1, sizeof(int), (void *)&wd);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_zero, 2, sizeof(int), (void *)&ht);
cl_int err = -666;
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_zero, sizes);
cl_int err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_zero, wd, ht,
CLARG(b->dev_grid), CLARG(wd), CLARG(ht));
if(err != CL_SUCCESS)
{
dt_bilateral_free_cl(b);
Expand All @@ -163,19 +159,9 @@ cl_int dt_bilateral_splat_cl(dt_bilateral_cl_t *b, cl_mem in)
cl_int err = -666;
size_t sizes[] = { ROUNDUP(b->width, b->blocksizex), ROUNDUP(b->height, b->blocksizey), 1 };
size_t local[] = { b->blocksizex, b->blocksizey, 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 0, sizeof(cl_mem), (void *)&in);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 1, sizeof(cl_mem), (void *)&b->dev_grid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 2, sizeof(int), (void *)&b->width);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 3, sizeof(int), (void *)&b->height);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 4, sizeof(int), (void *)&b->size_x);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 5, sizeof(int), (void *)&b->size_y);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 6, sizeof(int), (void *)&b->size_z);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 7, sizeof(float), (void *)&b->sigma_s);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 8, sizeof(float), (void *)&b->sigma_r);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 9, b->blocksizex * b->blocksizey * sizeof(int),
NULL);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_splat, 10,
b->blocksizex * b->blocksizey * 8 * sizeof(float), NULL);
dt_opencl_set_kernel_args(b->devid, b->global->kernel_splat, 0, CLARG(in), CLARG(b->dev_grid),
CLARG(b->width), CLARG(b->height), CLARG(b->size_x), CLARG(b->size_y), CLARG(b->size_z), CLARG(b->sigma_s),
CLARG(b->sigma_r), CLLOCAL(b->blocksizex * b->blocksizey * sizeof(int)), CLLOCAL(b->blocksizex * b->blocksizey * 8 * sizeof(float)));
err = dt_opencl_enqueue_kernel_2d_with_local(b->devid, b->global->kernel_splat, sizes, local);
return err;
}
Expand All @@ -186,7 +172,7 @@ cl_int dt_bilateral_blur_cl(dt_bilateral_cl_t *b)
size_t sizes[3] = { 0, 0, 1 };

err = dt_opencl_enqueue_copy_buffer_to_buffer(b->devid, b->dev_grid, b->dev_grid_tmp, 0, 0,
b->size_x * b->size_y * b->size_z * sizeof(float));
sizeof(float) * b->size_x * b->size_y * b->size_z);
if(err != CL_SUCCESS) return err;

sizes[0] = ROUNDUPDWD(b->size_z, b->devid);
Expand All @@ -195,14 +181,8 @@ cl_int dt_bilateral_blur_cl(dt_bilateral_cl_t *b)
stride1 = b->size_x * b->size_y;
stride2 = b->size_x;
stride3 = 1;
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 0, sizeof(cl_mem), (void *)&b->dev_grid_tmp);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 1, sizeof(cl_mem), (void *)&b->dev_grid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 2, sizeof(int), (void *)&stride1);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 3, sizeof(int), (void *)&stride2);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 4, sizeof(int), (void *)&stride3);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 5, sizeof(int), (void *)&b->size_z);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 6, sizeof(int), (void *)&b->size_y);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 7, sizeof(int), (void *)&b->size_x);
dt_opencl_set_kernel_args(b->devid, b->global->kernel_blur_line, 0, CLARG(b->dev_grid_tmp), CLARG(b->dev_grid),
CLARG(stride1), CLARG(stride2), CLARG(stride3), CLARG(b->size_z), CLARG(b->size_y), CLARG(b->size_x));
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_blur_line, sizes);
if(err != CL_SUCCESS) return err;

Expand All @@ -211,14 +191,8 @@ cl_int dt_bilateral_blur_cl(dt_bilateral_cl_t *b)
stride3 = b->size_x;
sizes[0] = ROUNDUPDWD(b->size_z, b->devid);
sizes[1] = ROUNDUPDHT(b->size_x, b->devid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 0, sizeof(cl_mem), (void *)&b->dev_grid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 1, sizeof(cl_mem), (void *)&b->dev_grid_tmp);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 2, sizeof(int), (void *)&stride1);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 3, sizeof(int), (void *)&stride2);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 4, sizeof(int), (void *)&stride3);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 5, sizeof(int), (void *)&b->size_z);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 6, sizeof(int), (void *)&b->size_x);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line, 7, sizeof(int), (void *)&b->size_y);
dt_opencl_set_kernel_args(b->devid, b->global->kernel_blur_line, 0, CLARG(b->dev_grid), CLARG(b->dev_grid_tmp),
CLARG(stride1), CLARG(stride2), CLARG(stride3), CLARG(b->size_z), CLARG(b->size_x), CLARG(b->size_y));
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_blur_line, sizes);
if(err != CL_SUCCESS) return err;

Expand All @@ -227,15 +201,8 @@ cl_int dt_bilateral_blur_cl(dt_bilateral_cl_t *b)
stride3 = b->size_x * b->size_y;
sizes[0] = ROUNDUPDWD(b->size_x, b->devid);
sizes[1] = ROUNDUPDHT(b->size_y, b->devid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 0, sizeof(cl_mem),
(void *)&b->dev_grid_tmp);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 1, sizeof(cl_mem), (void *)&b->dev_grid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 2, sizeof(int), (void *)&stride1);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 3, sizeof(int), (void *)&stride2);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 4, sizeof(int), (void *)&stride3);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 5, sizeof(int), (void *)&b->size_x);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 6, sizeof(int), (void *)&b->size_y);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_blur_line_z, 7, sizeof(int), (void *)&b->size_z);
dt_opencl_set_kernel_args(b->devid, b->global->kernel_blur_line_z, 0, CLARG(b->dev_grid_tmp), CLARG(b->dev_grid),
CLARG(stride1), CLARG(stride2), CLARG(stride3), CLARG(b->size_x), CLARG(b->size_y), CLARG(b->size_z));
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_blur_line_z, sizes);
return err;
}
Expand All @@ -253,20 +220,9 @@ cl_int dt_bilateral_slice_to_output_cl(dt_bilateral_cl_t *b, cl_mem in, cl_mem o
err = dt_opencl_enqueue_copy_image(b->devid, out, tmp, origin, origin, region);
if(err != CL_SUCCESS) goto error;

size_t sizes[] = { ROUNDUPDWD(b->width, b->devid), ROUNDUPDHT(b->height, b->devid), 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 0, sizeof(cl_mem), (void *)&in);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 1, sizeof(cl_mem), (void *)&tmp);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 2, sizeof(cl_mem), (void *)&out);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 3, sizeof(cl_mem), (void *)&b->dev_grid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 4, sizeof(int), (void *)&b->width);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 5, sizeof(int), (void *)&b->height);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 6, sizeof(int), (void *)&b->size_x);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 7, sizeof(int), (void *)&b->size_y);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 8, sizeof(int), (void *)&b->size_z);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 9, sizeof(float), (void *)&b->sigma_s);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 10, sizeof(float), (void *)&b->sigma_r);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice2, 11, sizeof(float), (void *)&detail);
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_slice2, sizes);
err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_slice2, b->width, b->height,
CLARG(in), CLARG(tmp), CLARG(out), CLARG(b->dev_grid), CLARG(b->width), CLARG(b->height), CLARG(b->size_x),
CLARG(b->size_y), CLARG(b->size_z), CLARG(b->sigma_s), CLARG(b->sigma_r), CLARG(detail));

dt_opencl_release_mem_object(tmp);
return err;
Expand All @@ -279,19 +235,9 @@ cl_int dt_bilateral_slice_to_output_cl(dt_bilateral_cl_t *b, cl_mem in, cl_mem o
cl_int dt_bilateral_slice_cl(dt_bilateral_cl_t *b, cl_mem in, cl_mem out, const float detail)
{
cl_int err = -666;
size_t sizes[] = { ROUNDUPDWD(b->width, b->devid), ROUNDUPDHT(b->height, b->devid), 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 0, sizeof(cl_mem), (void *)&in);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 1, sizeof(cl_mem), (void *)&out);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 2, sizeof(cl_mem), (void *)&b->dev_grid);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 3, sizeof(int), (void *)&b->width);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 4, sizeof(int), (void *)&b->height);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 5, sizeof(int), (void *)&b->size_x);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 6, sizeof(int), (void *)&b->size_y);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 7, sizeof(int), (void *)&b->size_z);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 8, sizeof(float), (void *)&b->sigma_s);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 9, sizeof(float), (void *)&b->sigma_r);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_slice, 10, sizeof(float), (void *)&detail);
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_slice, sizes);
err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_slice, b->width, b->height,
CLARG(in), CLARG(out), CLARG(b->dev_grid), CLARG(b->width), CLARG(b->height), CLARG(b->size_x),
CLARG(b->size_y), CLARG(b->size_z), CLARG(b->sigma_s), CLARG(b->sigma_r), CLARG(detail));
return err;
}

Expand Down
2 changes: 1 addition & 1 deletion src/common/bilateralcl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,7 @@ typedef struct dt_bilateral_cl_t
{
dt_bilateral_cl_global_t *global;
int devid;
size_t size_x, size_y, size_z;
int size_x, size_y, size_z;
int width, height;
size_t blocksizex, blocksizey;
float sigma_s, sigma_r;
Expand Down
4 changes: 4 additions & 0 deletions src/common/curl_tools.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,10 @@ void dt_curl_init(CURL *curl, gboolean verbose)
{
curl_easy_reset(curl);

char useragent[64];
snprintf(useragent, sizeof(useragent), "darktable/%s", darktable_package_version);
curl_easy_setopt(curl, CURLOPT_USERAGENT, useragent);

char datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
gchar *crtfilename = g_build_filename(datadir, "..", "curl", "curl-ca-bundle.crt", NULL);
Expand Down
30 changes: 30 additions & 0 deletions src/common/darktable.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -571,6 +571,12 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
" gPhoto2 support disabled\n"
#endif

#ifdef HAVE_LENSFUN
" Lensfun support enabled\n"
#else
" Lensfun support disabled\n"
#endif

#ifdef HAVE_GRAPHICSMAGICK
" GraphicsMagick support enabled\n"
#else
Expand All @@ -583,11 +589,35 @@ int dt_init(int argc, char *argv[], const gboolean init_gui, const gboolean load
" ImageMagick support disabled\n"
#endif

#ifdef HAVE_LIBAVIF
" libavif support enabled\n"
#else
" libavif support disabled\n"
#endif

#ifdef HAVE_LIBHEIF
" libheif support enabled\n"
#else
" libheif support disabled\n"
#endif

#ifdef HAVE_OPENJPEG
" OpenJPEG support enabled\n"
#else
" OpenJPEG support disabled\n"
#endif

#ifdef HAVE_OPENEXR
" OpenEXR support enabled\n"
#else
" OpenEXR support disabled\n"
#endif

#ifdef HAVE_WEBP
" WebP support enabled\n"
#else
" WebP support disabled\n"
#endif
,
darktable_package_string,
darktable_last_commit_year,
Expand Down
52 changes: 12 additions & 40 deletions src/common/dwt.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -603,18 +603,13 @@ static cl_int dwt_subtract_layer_cl(cl_mem bl, cl_mem bh, dwt_params_cl_t *const
const int devid = p->devid;
const int kernel = p->global->kernel_dwt_subtract_layer;

size_t sizes[] = { ROUNDUPDWD(p->width, devid), ROUNDUPDHT(p->height, devid), 1 };

const float lpass_mult = (1.f / 16.f);
const int width = p->width;
const int height = p->height;

dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&bl);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&bh);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(width));
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&(height));
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(float), (void *)&lpass_mult);
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, p->width, p->height,
CLARG(bl), CLARG(bh), CLARG((width)), CLARG((height)), CLARG(lpass_mult));

return err;
}
Expand All @@ -626,16 +621,12 @@ static cl_int dwt_add_layer_cl(cl_mem img, cl_mem layers, dwt_params_cl_t *const
const int devid = p->devid;
const int kernel = p->global->kernel_dwt_add_img_to_layer;

size_t sizes[] = { ROUNDUPDWD(p->width, devid), ROUNDUPDHT(p->height, devid), 1 };

const int width = p->width;
const int height = p->height;

dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&img);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&layers);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(width));
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&(height));
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, p->width, p->height,
CLARG(img), CLARG(layers), CLARG((width)), CLARG((height)));

return err;
}
Expand Down Expand Up @@ -695,14 +686,11 @@ static cl_int dwt_wavelet_decompose_cl(cl_mem img, dwt_params_cl_t *const p, _dw
{
const int kernel = p->global->kernel_dwt_init_buffer;

size_t sizes[] = { ROUNDUPDWD(p->width, devid), ROUNDUPDHT(p->height, devid), 1 };
const int width = p->width;
const int height = p->height;

dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&layers);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(int), (void *)&(width));
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(height));
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, p->width, p->height,
CLARG(layers), CLARG((width)), CLARG((height)));
if(err != CL_SUCCESS) goto cleanup;
}

Expand All @@ -719,14 +707,11 @@ static cl_int dwt_wavelet_decompose_cl(cl_mem img, dwt_params_cl_t *const p, _dw
{
const int kernel = p->global->kernel_dwt_init_buffer;

size_t sizes[] = { ROUNDUPDWD(p->width, devid), ROUNDUPDHT(p->height, devid), 1 };
const int width = p->width;
const int height = p->height;

dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&merged_layers);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(int), (void *)&(width));
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(height));
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, p->width, p->height,
CLARG(merged_layers), CLARG((width)), CLARG((height)));
if(err != CL_SUCCESS) goto cleanup;
}
}
Expand Down Expand Up @@ -756,14 +741,8 @@ static cl_int dwt_wavelet_decompose_cl(cl_mem img, dwt_params_cl_t *const p, _dw
sc = (int)(sc * p->preview_scale);
if(sc > p->width) sc = p->width;

size_t sizes[] = { ROUNDUPDWD(p->width, devid), ROUNDUPDHT(p->height, devid), 1 };

dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&temp);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&(buffer[hpass]));
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(p->width));
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&(p->height));
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(int), (void *)&sc);
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, p->width, p->height,
CLARG(temp), CLARG((buffer[hpass])), CLARG((p->width)), CLARG((p->height)), CLARG(sc));
if(err != CL_SUCCESS) goto cleanup;
}

Expand All @@ -776,15 +755,8 @@ static cl_int dwt_wavelet_decompose_cl(cl_mem img, dwt_params_cl_t *const p, _dw
if(sc > p->height) sc = p->height;
const float lpass_mult = (1.f / 16.f);

size_t sizes[] = { ROUNDUPDWD(p->width, devid), ROUNDUPDHT(p->height, devid), 1 };

dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&temp);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(int), (void *)&(p->width));
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(p->height));
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&sc);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(cl_mem), (void *)&(buffer[lpass]));
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(float), (void *)&lpass_mult);
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, p->width, p->height,
CLARG(temp), CLARG((p->width)), CLARG((p->height)), CLARG(sc), CLARG((buffer[lpass])), CLARG(lpass_mult));
if(err != CL_SUCCESS) goto cleanup;
}

Expand Down
50 changes: 10 additions & 40 deletions src/common/gaussian.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -666,33 +666,18 @@ cl_int dt_gaussian_blur_cl(dt_gaussian_cl_t *g, cl_mem dev_in, cl_mem dev_out)
sizes[0] = ROUNDUPDWD(width, devid);
sizes[1] = 1;
sizes[2] = 1;
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 0, sizeof(cl_mem), (void *)&dev_temp1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 1, sizeof(cl_mem), (void *)&dev_temp2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 4, sizeof(float), (void *)&a0);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 5, sizeof(float), (void *)&a1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 6, sizeof(float), (void *)&a2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 7, sizeof(float), (void *)&a3);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 8, sizeof(float), (void *)&b1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 9, sizeof(float), (void *)&b2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 10, sizeof(float), (void *)&coefp);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 11, sizeof(float), (void *)&coefn);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 12, sizeof(float) * channels, (void *)&Labmax);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 13, sizeof(float) * channels, (void *)&Labmin);
dt_opencl_set_kernel_args(devid, kernel_gaussian_column, 0, CLARG(dev_temp1), CLARG(dev_temp2),
CLARG(width), CLARG(height), CLARG(a0), CLARG(a1), CLARG(a2), CLARG(a3), CLARG(b1), CLARG(b2),
CLARG(coefp), CLARG(coefn), CLARG(Labmax), CLARG(Labmin));
err = dt_opencl_enqueue_kernel_2d(devid, kernel_gaussian_column, sizes);
if(err != CL_SUCCESS) return err;

// intermediate step: transpose dev_temp2 -> dev_temp1
sizes[0] = bwidth;
sizes[1] = bheight;
sizes[2] = 1;
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 0, sizeof(cl_mem), (void *)&dev_temp2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 1, sizeof(cl_mem), (void *)&dev_temp1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 4, sizeof(int), (void *)&blocksize);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 5, bpp * blocksize * (blocksize + 1), NULL);
dt_opencl_set_kernel_args(devid, kernel_gaussian_transpose, 0, CLARG(dev_temp2), CLARG(dev_temp1),
CLARG(width), CLARG(height), CLARG(blocksize), CLLOCAL(bpp * blocksize * (blocksize + 1)));
err = dt_opencl_enqueue_kernel_2d_with_local(devid, kernel_gaussian_transpose, sizes, local);
if(err != CL_SUCCESS) return err;

Expand All @@ -702,20 +687,9 @@ cl_int dt_gaussian_blur_cl(dt_gaussian_cl_t *g, cl_mem dev_in, cl_mem dev_out)
sizes[0] = ROUNDUPDHT(height, devid);
sizes[1] = 1;
sizes[2] = 1;
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 0, sizeof(cl_mem), (void *)&dev_temp1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 1, sizeof(cl_mem), (void *)&dev_temp2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 2, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 3, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 4, sizeof(float), (void *)&a0);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 5, sizeof(float), (void *)&a1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 6, sizeof(float), (void *)&a2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 7, sizeof(float), (void *)&a3);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 8, sizeof(float), (void *)&b1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 9, sizeof(float), (void *)&b2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 10, sizeof(float), (void *)&coefp);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 11, sizeof(float), (void *)&coefn);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 12, sizeof(float) * channels, (void *)&Labmax);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_column, 13, sizeof(float) * channels, (void *)&Labmin);
dt_opencl_set_kernel_args(devid, kernel_gaussian_column, 0, CLARG(dev_temp1), CLARG(dev_temp2),
CLARG(height), CLARG(width), CLARG(a0), CLARG(a1), CLARG(a2), CLARG(a3), CLARG(b1), CLARG(b2),
CLARG(coefp), CLARG(coefn), CLARG(Labmax), CLARG(Labmin));
err = dt_opencl_enqueue_kernel_2d(devid, kernel_gaussian_column, sizes);
if(err != CL_SUCCESS) return err;

Expand All @@ -724,12 +698,8 @@ cl_int dt_gaussian_blur_cl(dt_gaussian_cl_t *g, cl_mem dev_in, cl_mem dev_out)
sizes[0] = bheight;
sizes[1] = bwidth;
sizes[2] = 1;
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 0, sizeof(cl_mem), (void *)&dev_temp2);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 1, sizeof(cl_mem), (void *)&dev_temp1);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 2, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 3, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 4, sizeof(int), (void *)&blocksize);
dt_opencl_set_kernel_arg(devid, kernel_gaussian_transpose, 5, bpp * blocksize * (blocksize + 1), NULL);
dt_opencl_set_kernel_args(devid, kernel_gaussian_transpose, 0, CLARG(dev_temp2), CLARG(dev_temp1),
CLARG(height), CLARG(width), CLARG(blocksize), CLLOCAL(bpp * blocksize * (blocksize + 1)));
err = dt_opencl_enqueue_kernel_2d_with_local(devid, kernel_gaussian_transpose, sizes, local);
if(err != CL_SUCCESS) return err;

Expand Down
104 changes: 20 additions & 84 deletions src/common/guided_filter.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -371,37 +371,22 @@ static int cl_split_rgb(const int devid, const int width, const int height, cl_m
cl_mem imgg_g, cl_mem imgg_b, const float guide_weight)
{
const int kernel = darktable.opencl->guided_filter->kernel_guided_filter_split_rgb;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(guide), &guide);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(imgg_r), &imgg_r);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(imgg_g), &imgg_g);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(imgg_b), &imgg_b);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(guide_weight), &guide_weight);
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid) };
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
return dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(width), CLARG(height), CLARG(guide), CLARG(imgg_r), CLARG(imgg_g), CLARG(imgg_b), CLARG(guide_weight));
}


static int cl_box_mean(const int devid, const int width, const int height, const int w, cl_mem in, cl_mem out,
cl_mem temp)
{
const int kernel_x = darktable.opencl->guided_filter->kernel_guided_filter_box_mean_x;
dt_opencl_set_kernel_arg(devid, kernel_x, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel_x, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel_x, 2, sizeof(in), &in);
dt_opencl_set_kernel_arg(devid, kernel_x, 3, sizeof(temp), &temp);
dt_opencl_set_kernel_arg(devid, kernel_x, 4, sizeof(w), &w);
dt_opencl_set_kernel_args(devid, kernel_x, 0, CLARG(width), CLARG(height), CLARG(in), CLARG(temp), CLARG(w));
const size_t sizes_x[] = { 1, ROUNDUPDHT(height, devid) };
const int err = dt_opencl_enqueue_kernel_2d(devid, kernel_x, sizes_x);
if(err != CL_SUCCESS) return err;

const int kernel_y = darktable.opencl->guided_filter->kernel_guided_filter_box_mean_y;
dt_opencl_set_kernel_arg(devid, kernel_y, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel_y, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel_y, 2, sizeof(temp), &temp);
dt_opencl_set_kernel_arg(devid, kernel_y, 3, sizeof(out), &out);
dt_opencl_set_kernel_arg(devid, kernel_y, 4, sizeof(w), &w);
dt_opencl_set_kernel_args(devid, kernel_y, 0, CLARG(width), CLARG(height), CLARG(temp), CLARG(out), CLARG(w));
const size_t sizes_y[] = { ROUNDUPDWD(width, devid), 1 };
return dt_opencl_enqueue_kernel_2d(devid, kernel_y, sizes_y);
}
Expand All @@ -412,16 +397,9 @@ static int cl_covariances(const int devid, const int width, const int height, cl
const float guide_weight)
{
const int kernel = darktable.opencl->guided_filter->kernel_guided_filter_guided_filter_covariances;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(guide), &guide);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(in), &in);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(cov_imgg_img_r), &cov_imgg_img_r);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(cov_imgg_img_g), &cov_imgg_img_g);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(cov_imgg_img_b), &cov_imgg_img_b);
dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(guide_weight), &guide_weight);
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid) };
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
return dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(width), CLARG(height), CLARG(guide), CLARG(in), CLARG(cov_imgg_img_r), CLARG(cov_imgg_img_g),
CLARG(cov_imgg_img_b), CLARG(guide_weight));
}


Expand All @@ -430,34 +408,18 @@ static int cl_variances(const int devid, const int width, const int height, cl_m
cl_mem var_imgg_bb, const float guide_weight)
{
const int kernel = darktable.opencl->guided_filter->kernel_guided_filter_guided_filter_variances;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(guide), &guide);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(var_imgg_rr), &var_imgg_rr);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(var_imgg_rg), &var_imgg_rg);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(var_imgg_rb), &var_imgg_rb);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(var_imgg_gg), &var_imgg_gg);
dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(var_imgg_gb), &var_imgg_gb);
dt_opencl_set_kernel_arg(devid, kernel, 8, sizeof(var_imgg_bb), &var_imgg_bb);
dt_opencl_set_kernel_arg(devid, kernel, 9, sizeof(guide_weight), &guide_weight);
size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid) };
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
return dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(width), CLARG(height), CLARG(guide), CLARG(var_imgg_rr), CLARG(var_imgg_rg), CLARG(var_imgg_rb),
CLARG(var_imgg_gg), CLARG(var_imgg_gb), CLARG(var_imgg_bb), CLARG(guide_weight));
}


static int cl_update_covariance(const int devid, const int width, const int height, cl_mem in, cl_mem out,
cl_mem a, cl_mem b, float eps)
{
const int kernel = darktable.opencl->guided_filter->kernel_guided_filter_update_covariance;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(in), &in);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(out), &out);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(a), &a);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(b), &b);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(eps), &eps);
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid) };
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
return dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(width), CLARG(height), CLARG(in), CLARG(out), CLARG(a), CLARG(b), CLARG(eps));
}


Expand All @@ -468,27 +430,11 @@ static int cl_solve(const int devid, const int width, const int height, cl_mem i
cl_mem b)
{
const int kernel = darktable.opencl->guided_filter->kernel_guided_filter_solve;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(img_mean), &img_mean);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(imgg_mean_r), &imgg_mean_r);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(imgg_mean_g), &imgg_mean_g);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(imgg_mean_b), &imgg_mean_b);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(cov_imgg_img_r), &cov_imgg_img_r);
dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(cov_imgg_img_g), &cov_imgg_img_g);
dt_opencl_set_kernel_arg(devid, kernel, 8, sizeof(cov_imgg_img_b), &cov_imgg_img_b);
dt_opencl_set_kernel_arg(devid, kernel, 9, sizeof(var_imgg_rr), &var_imgg_rr);
dt_opencl_set_kernel_arg(devid, kernel, 10, sizeof(var_imgg_rg), &var_imgg_rg);
dt_opencl_set_kernel_arg(devid, kernel, 11, sizeof(var_imgg_rb), &var_imgg_rb);
dt_opencl_set_kernel_arg(devid, kernel, 12, sizeof(var_imgg_gg), &var_imgg_gg);
dt_opencl_set_kernel_arg(devid, kernel, 13, sizeof(var_imgg_gb), &var_imgg_gb);
dt_opencl_set_kernel_arg(devid, kernel, 14, sizeof(var_imgg_bb), &var_imgg_bb);
dt_opencl_set_kernel_arg(devid, kernel, 15, sizeof(a_r), &a_r);
dt_opencl_set_kernel_arg(devid, kernel, 16, sizeof(a_g), &a_g);
dt_opencl_set_kernel_arg(devid, kernel, 17, sizeof(a_b), &a_b);
dt_opencl_set_kernel_arg(devid, kernel, 18, sizeof(b), &b);
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid) };
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
return dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(width), CLARG(height), CLARG(img_mean), CLARG(imgg_mean_r), CLARG(imgg_mean_g), CLARG(imgg_mean_b),
CLARG(cov_imgg_img_r), CLARG(cov_imgg_img_g), CLARG(cov_imgg_img_b), CLARG(var_imgg_rr), CLARG(var_imgg_rg),
CLARG(var_imgg_rb), CLARG(var_imgg_gg), CLARG(var_imgg_gb), CLARG(var_imgg_bb), CLARG(a_r), CLARG(a_g),
CLARG(a_b), CLARG(b));
}


Expand All @@ -497,19 +443,9 @@ static int cl_generate_result(const int devid, const int width, const int height
const float min, const float max)
{
const int kernel = darktable.opencl->guided_filter->kernel_guided_filter_generate_result;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(width), &width);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(height), &height);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(guide), &guide);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(a_r), &a_r);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(a_g), &a_g);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(a_b), &a_b);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(b), &b);
dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(out), &out);
dt_opencl_set_kernel_arg(devid, kernel, 8, sizeof(guide_weight), &guide_weight);
dt_opencl_set_kernel_arg(devid, kernel, 9, sizeof(min), &min);
dt_opencl_set_kernel_arg(devid, kernel, 10, sizeof(max), &max);
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid) };
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
return dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(width), CLARG(height), CLARG(guide), CLARG(a_r), CLARG(a_g), CLARG(a_b), CLARG(b), CLARG(out),
CLARG(guide_weight), CLARG(min), CLARG(max));
}


Expand Down
13 changes: 6 additions & 7 deletions src/common/imageio.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -772,13 +772,14 @@ int dt_imageio_export_with_flags(const int32_t imgid, const char *filename,
dt_times_t start;
dt_get_times(&start);
dt_dev_pixelpipe_t pipe;
gboolean res = thumbnail_export ? dt_dev_pixelpipe_init_thumbnail(&pipe, wd, ht)
: dt_dev_pixelpipe_init_export(&pipe, wd, ht, format->levels(format_params), export_masks);
gboolean res = thumbnail_export
? dt_dev_pixelpipe_init_thumbnail(&pipe, wd, ht)
: dt_dev_pixelpipe_init_export(&pipe, wd, ht, format->levels(format_params), export_masks);
if(!res)
{
dt_control_log(
_("failed to allocate memory for %s, please lower the threads used for export or buy more memory."),
thumbnail_export ? C_("noun", "thumbnail export") : C_("noun", "export"));
_("failed to allocate memory for %s, please lower the threads used for export or buy more memory."),
thumbnail_export ? C_("noun", "thumbnail export") : C_("noun", "export"));
goto error;
}

Expand Down Expand Up @@ -1123,15 +1124,14 @@ int dt_imageio_export_with_flags(const int32_t imgid, const char *filename,

if(!ignore_exif)
{
int length;
uint8_t *exif_profile = NULL; // Exif data should be 65536 bytes max, but if original size is close to that,
// adding new tags could make it go over that... so let it be and see what
// happens when we write the image
char pathname[PATH_MAX] = { 0 };
gboolean from_cache = TRUE;
dt_image_full_path(imgid, pathname, sizeof(pathname), &from_cache);
// last param is dng mode, it's false here
length = dt_exif_read_blob(&exif_profile, pathname, imgid, sRGB, processed_width, processed_height, 0);
const int length = dt_exif_read_blob(&exif_profile, pathname, imgid, sRGB, processed_width, processed_height, 0);

res = format->write_image(format_params, filename, outbuf, icc_type, icc_filename, exif_profile, length, imgid,
num, total, &pipe, export_masks);
Expand Down Expand Up @@ -1335,4 +1335,3 @@ gboolean dt_imageio_lookup_makermodel(const char *maker, const char *model,
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on

1 change: 0 additions & 1 deletion src/common/imageio.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -122,4 +122,3 @@ dt_image_flags_t dt_imageio_get_type_from_extension(const char *extension);
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on

21 changes: 4 additions & 17 deletions src/common/interpolation.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1931,23 +1931,10 @@ int dt_interpolation_resample_cl(const struct dt_interpolation *itor, int devid,
dev_vmeta = dt_opencl_copy_host_to_device_constant(devid, sizeof(int) * height * 3, vmeta);
if(dev_vmeta == NULL) goto error;

dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(cl_mem), (void *)&dev_hmeta);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(cl_mem), (void *)&dev_vmeta);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(cl_mem), (void *)&dev_hlength);
dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(cl_mem), (void *)&dev_vlength);
dt_opencl_set_kernel_arg(devid, kernel, 8, sizeof(cl_mem), (void *)&dev_hindex);
dt_opencl_set_kernel_arg(devid, kernel, 9, sizeof(cl_mem), (void *)&dev_vindex);
dt_opencl_set_kernel_arg(devid, kernel, 10, sizeof(cl_mem), (void *)&dev_hkernel);
dt_opencl_set_kernel_arg(devid, kernel, 11, sizeof(cl_mem), (void *)&dev_vkernel);
dt_opencl_set_kernel_arg(devid, kernel, 12, sizeof(int), (void *)&hmaxtaps);
dt_opencl_set_kernel_arg(devid, kernel, 13, sizeof(int), (void *)&taps);
dt_opencl_set_kernel_arg(devid, kernel, 14, hmaxtaps * sizeof(float), NULL);
dt_opencl_set_kernel_arg(devid, kernel, 15, hmaxtaps * sizeof(int), NULL);
dt_opencl_set_kernel_arg(devid, kernel, 16, vblocksize * 4 * sizeof(float), NULL);
dt_opencl_set_kernel_args(devid, kernel, 0, CLARG(dev_in), CLARG(dev_out), CLARG(width), CLARG(height),
CLARG(dev_hmeta), CLARG(dev_vmeta), CLARG(dev_hlength), CLARG(dev_vlength), CLARG(dev_hindex),
CLARG(dev_vindex), CLARG(dev_hkernel), CLARG(dev_vkernel), CLARG(hmaxtaps), CLARG(taps), CLLOCAL(hmaxtaps * sizeof(float)),
CLLOCAL(hmaxtaps * sizeof(int)), CLLOCAL(vblocksize * 4 * sizeof(float)));
err = dt_opencl_enqueue_kernel_2d_with_local(devid, kernel, sizes, local);
if(err != CL_SUCCESS) goto error;

Expand Down
26 changes: 5 additions & 21 deletions src/common/iop_profile.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1393,15 +1393,8 @@ int dt_ioppr_transform_image_colorspace_cl(struct dt_iop_module_t *self, const i
goto cleanup;
}

size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };

dt_opencl_set_kernel_arg(devid, kernel_transform, 0, sizeof(cl_mem), (void *)&dev_tmp);
dt_opencl_set_kernel_arg(devid, kernel_transform, 1, sizeof(cl_mem), (void *)&dev_img_out);
dt_opencl_set_kernel_arg(devid, kernel_transform, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel_transform, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel_transform, 4, sizeof(cl_mem), (void *)&dev_profile_info);
dt_opencl_set_kernel_arg(devid, kernel_transform, 5, sizeof(cl_mem), (void *)&dev_lut);
err = dt_opencl_enqueue_kernel_2d(devid, kernel_transform, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel_transform, width, height,
CLARG(dev_tmp), CLARG(dev_img_out), CLARG(width), CLARG(height), CLARG(dev_profile_info), CLARG(dev_lut));
if(err != CL_SUCCESS)
{
fprintf(stderr, "[dt_ioppr_transform_image_colorspace_cl] error %i enqueue kernel for color transformation\n", err);
Expand Down Expand Up @@ -1602,18 +1595,9 @@ int dt_ioppr_transform_image_colorspace_rgb_cl(const int devid, cl_mem dev_img_i
goto cleanup;
}

size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };

dt_opencl_set_kernel_arg(devid, kernel_transform, 0, sizeof(cl_mem), (void *)&dev_tmp);
dt_opencl_set_kernel_arg(devid, kernel_transform, 1, sizeof(cl_mem), (void *)&dev_img_out);
dt_opencl_set_kernel_arg(devid, kernel_transform, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel_transform, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel_transform, 4, sizeof(cl_mem), (void *)&dev_profile_info_from);
dt_opencl_set_kernel_arg(devid, kernel_transform, 5, sizeof(cl_mem), (void *)&dev_lut_from);
dt_opencl_set_kernel_arg(devid, kernel_transform, 6, sizeof(cl_mem), (void *)&dev_profile_info_to);
dt_opencl_set_kernel_arg(devid, kernel_transform, 7, sizeof(cl_mem), (void *)&dev_lut_to);
dt_opencl_set_kernel_arg(devid, kernel_transform, 8, sizeof(cl_mem), (void *)&matrix_cl);
err = dt_opencl_enqueue_kernel_2d(devid, kernel_transform, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel_transform, width, height,
CLARG(dev_tmp), CLARG(dev_img_out), CLARG(width), CLARG(height), CLARG(dev_profile_info_from),
CLARG(dev_lut_from), CLARG(dev_profile_info_to), CLARG(dev_lut_to), CLARG(matrix_cl));
if(err != CL_SUCCESS)
{
fprintf(stderr,
Expand Down
82 changes: 20 additions & 62 deletions src/common/locallaplaciancl.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -130,58 +130,40 @@ cl_int dt_local_laplacian_cl(

if(b->bwidth <= 1 || b->bheight <= 1) return err;

size_t sizes_pad[] = { ROUNDUPDWD(b->bwidth, b->devid), ROUNDUPDHT(b->bheight, b->devid), 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_pad_input, 0, sizeof(cl_mem), &input);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_pad_input, 1, sizeof(cl_mem), &b->dev_padded[0]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_pad_input, 2, sizeof(int), &b->width);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_pad_input, 3, sizeof(int), &b->height);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_pad_input, 4, sizeof(int), &b->max_supp);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_pad_input, 5, sizeof(int), &b->bwidth);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_pad_input, 6, sizeof(int), &b->bheight);
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_pad_input, sizes_pad);
err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_pad_input, b->bwidth, b->bheight,
CLARG(input), CLARG(b->dev_padded[0]), CLARG(b->width), CLARG(b->height), CLARG(b->max_supp), CLARG(b->bwidth),
CLARG(b->bheight));
if(err != CL_SUCCESS) goto error;

// create gauss pyramid of padded input, write coarse directly to output
for(int l=1;l<b->num_levels;l++)
{
const int wd = dl(b->bwidth, l), ht = dl(b->bheight, l);
size_t sizes[] = { ROUNDUPDWD(wd, b->devid), ROUNDUPDHT(ht, b->devid), 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 0, sizeof(cl_mem), &b->dev_padded[l-1]);
dt_opencl_set_kernel_args(b->devid, b->global->kernel_gauss_reduce, 0, CLARG(b->dev_padded[l-1]));
if(l == b->num_levels-1)
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 1, sizeof(cl_mem), &b->dev_output[l]);
dt_opencl_set_kernel_args(b->devid, b->global->kernel_gauss_reduce, 1, CLARG(b->dev_output[l]));
else
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 1, sizeof(cl_mem), &b->dev_padded[l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 2, sizeof(int), &wd);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 3, sizeof(int), &ht);
dt_opencl_set_kernel_args(b->devid, b->global->kernel_gauss_reduce, 1, CLARG(b->dev_padded[l]));
dt_opencl_set_kernel_args(b->devid, b->global->kernel_gauss_reduce, 2, CLARG(wd), CLARG(ht));
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_gauss_reduce, sizes);
if(err != CL_SUCCESS) goto error;
}

for(int k=0;k<num_gamma;k++)
{ // process images
const float g = (k+.5f)/(float)num_gamma;
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 0, sizeof(cl_mem), &b->dev_padded[0]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 1, sizeof(cl_mem), &b->dev_processed[k][0]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 2, sizeof(float), &g);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 3, sizeof(float), &b->sigma);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 4, sizeof(float), &b->shadows);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 5, sizeof(float), &b->highlights);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 6, sizeof(float), &b->clarity);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 7, sizeof(int), &b->bwidth);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_process_curve, 8, sizeof(int), &b->bheight);
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_process_curve, sizes_pad);
err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_process_curve, b->bwidth, b->bheight,
CLARG(b->dev_padded[0]), CLARG(b->dev_processed[k][0]), CLARG(g), CLARG(b->sigma), CLARG(b->shadows),
CLARG(b->highlights), CLARG(b->clarity), CLARG(b->bwidth), CLARG(b->bheight));
if(err != CL_SUCCESS) goto error;

// create gaussian pyramids
for(int l=1;l<b->num_levels;l++)
{
const int wd = dl(b->bwidth, l), ht = dl(b->bheight, l);
size_t sizes[] = { ROUNDUPDWD(wd, b->devid), ROUNDUPDHT(ht, b->devid), 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 0, sizeof(cl_mem), &b->dev_processed[k][l-1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 1, sizeof(cl_mem), &b->dev_processed[k][l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 2, sizeof(int), &wd);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_gauss_reduce, 3, sizeof(int), &ht);
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_gauss_reduce, sizes);
err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_gauss_reduce, wd, ht,
CLARG(b->dev_processed[k][l-1]), CLARG(b->dev_processed[k][l]), CLARG(wd), CLARG(ht));
if(err != CL_SUCCESS) goto error;
}
}
Expand All @@ -190,42 +172,18 @@ cl_int dt_local_laplacian_cl(
for(int l=b->num_levels-2;l >= 0; l--)
{
const int pw = dl(b->bwidth,l), ph = dl(b->bheight,l);
size_t sizes[] = { ROUNDUPDWD(pw, b->devid), ROUNDUPDHT(ph, b->devid), 1 };
// this is so dumb:
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 0, sizeof(cl_mem), &b->dev_padded[l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 1, sizeof(cl_mem), &b->dev_output[l+1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 2, sizeof(cl_mem), &b->dev_output[l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 3, sizeof(cl_mem), &b->dev_processed[0][l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 4, sizeof(cl_mem), &b->dev_processed[0][l+1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 5, sizeof(cl_mem), &b->dev_processed[1][l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 6, sizeof(cl_mem), &b->dev_processed[1][l+1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 7, sizeof(cl_mem), &b->dev_processed[2][l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 8, sizeof(cl_mem), &b->dev_processed[2][l+1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 9, sizeof(cl_mem), &b->dev_processed[3][l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 10, sizeof(cl_mem), &b->dev_processed[3][l+1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 11, sizeof(cl_mem), &b->dev_processed[4][l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 12, sizeof(cl_mem), &b->dev_processed[4][l+1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 13, sizeof(cl_mem), &b->dev_processed[5][l]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 14, sizeof(cl_mem), &b->dev_processed[5][l+1]);
// dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 15, sizeof(cl_mem), &b->dev_processed[6][l]);
// dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 16, sizeof(cl_mem), &b->dev_processed[6][l+1]);
// dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 17, sizeof(cl_mem), &b->dev_processed[7][l]);
// dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 18, sizeof(cl_mem), &b->dev_processed[7][l+1]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 15, sizeof(int), &pw);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_laplacian_assemble, 16, sizeof(int), &ph);
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_laplacian_assemble, sizes);
err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_laplacian_assemble, pw, ph,
CLARG(b->dev_padded[l]), CLARG(b->dev_output[l+1]), CLARG(b->dev_output[l]), CLARG(b->dev_processed[0][l]),
CLARG(b->dev_processed[0][l+1]), CLARG(b->dev_processed[1][l]), CLARG(b->dev_processed[1][l+1]),
CLARG(b->dev_processed[2][l]), CLARG(b->dev_processed[2][l+1]), CLARG(b->dev_processed[3][l]),
CLARG(b->dev_processed[3][l+1]), CLARG(b->dev_processed[4][l]), CLARG(b->dev_processed[4][l+1]),
CLARG(b->dev_processed[5][l]), CLARG(b->dev_processed[5][l+1]), CLARG(pw), CLARG(ph));
if(err != CL_SUCCESS) goto error;
}

// read back processed L channel and copy colours:
size_t sizes[] = { ROUNDUPDWD(b->width, b->devid), ROUNDUPDHT(b->height, b->devid), 1 };
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_write_back, 0, sizeof(cl_mem), &input);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_write_back, 1, sizeof(cl_mem), &b->dev_output[0]);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_write_back, 2, sizeof(cl_mem), &output);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_write_back, 3, sizeof(int), &b->max_supp);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_write_back, 4, sizeof(int), &b->width);
dt_opencl_set_kernel_arg(b->devid, b->global->kernel_write_back, 5, sizeof(int), &b->height);
err = dt_opencl_enqueue_kernel_2d(b->devid, b->global->kernel_write_back, sizes);
err = dt_opencl_enqueue_kernel_2d_args(b->devid, b->global->kernel_write_back, b->width, b->height,
CLARG(input), CLARG(b->dev_output[0]), CLARG(output), CLARG(b->max_supp), CLARG(b->width), CLARG(b->height));
if(err != CL_SUCCESS) goto error;

return CL_SUCCESS;
Expand Down
2 changes: 1 addition & 1 deletion src/common/locallaplaciancl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@ typedef struct dt_local_laplacian_cl_t
float sigma, highlights, shadows, clarity;
int blocksize, blockwd, blockht;
int max_supp;
size_t bwidth, bheight;
int bwidth, bheight;

// pyramid of padded monochrome input buffer
cl_mem *dev_padded;
Expand Down
1 change: 0 additions & 1 deletion src/common/mipmap_cache.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1341,4 +1341,3 @@ void dt_mipmap_cache_copy_thumbnails(const dt_mipmap_cache_t *cache, const uint3
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on

67 changes: 17 additions & 50 deletions src/common/nlmeans_core.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -872,11 +872,8 @@ static void get_blocksizes(int *h, int *v, const int radius, const int devid,
static inline cl_int nlmeans_cl_init(const int devid, const int kernel, cl_mem dev_out, const int height,
const int width)
{
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&height);
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
return dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(dev_out), CLARG(width), CLARG(height));
}
#endif /* HAVE_OPENCL */

Expand All @@ -888,13 +885,8 @@ static inline cl_int nlmeans_cl_horiz(const int devid, const int kernel, cl_mem
{
const size_t sizesl[3] = { bwidth, ROUNDUPDHT(height, devid), 1 };
const size_t local[3] = { hblocksize, 1, 1 };
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_U4);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_U4_t);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel, 4, 2 * sizeof(int), (void *)&q);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(int), (void *)&P);
dt_opencl_set_kernel_arg(devid, kernel, 6, (hblocksize + 2 * P) * sizeof(float), NULL);
dt_opencl_set_kernel_args(devid, kernel, 0, CLARG(dev_U4), CLARG(dev_U4_t), CLARG(width), CLARG(height), CLARRAY(2, q),
CLARG(P), CLLOCAL((hblocksize + 2 * P) * sizeof(float)));
return dt_opencl_enqueue_kernel_2d_with_local(devid, kernel, sizesl, local);
}
#endif /* HAVE_OPENCL */
Expand All @@ -905,12 +897,8 @@ static inline cl_int nlmeans_cl_accu(const int devid, const int kernel, cl_mem d
cl_mem dev_out, const int q[2], const int height, const int width,
const size_t sizes[3])
{
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(cl_mem), (void *)&dev_U4_tt);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel, 5, 2 * sizeof(int), (void *)&q);
dt_opencl_set_kernel_args(devid, kernel, 0, CLARG(dev_in), CLARG(dev_out), CLARG(dev_U4_tt), CLARG(width),
CLARG(height), CLARRAY(2, q));
return dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
}
#endif /* HAVE_OPENCL */
Expand Down Expand Up @@ -950,22 +938,17 @@ int nlmeans_denoise_cl(const dt_nlmeans_param_t *const params, const int devid,

const size_t bwidth = ROUNDUP(width, hblocksize);
const size_t bheight = ROUNDUP(height, vblocksize);
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };

for(int p = 0; p < num_patches; p++)
{
const patch_t *patch = &patches[p];
int q[2] = { patch->rows, patch->cols };
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };

// compute channel-normed squared differences between input pixels and shifted (by q) pixels
cl_mem dev_U4 = buckets[bucket_next(&state, NUM_BUCKETS)];
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 1, sizeof(cl_mem), (void *)&dev_U4);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 4, 2 * sizeof(int), (void *)&q);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 5, sizeof(float), (void *)&nL2);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 6, sizeof(float), (void *)&nC2);
dt_opencl_set_kernel_args(devid, params->kernel_dist, 0, CLARG(dev_in), CLARG(dev_U4), CLARG(width),
CLARG(height), CLARG(q), CLARG(nL2), CLARG(nC2));
err = dt_opencl_enqueue_kernel_2d(devid, params->kernel_dist, sizes);
if(err != CL_SUCCESS) break;

Expand All @@ -979,14 +962,8 @@ int nlmeans_denoise_cl(const dt_nlmeans_param_t *const params, const int devid,
const size_t local[3] = { 1, vblocksize, 1 };
const float sharpness = params->sharpness;
cl_mem dev_U4_tt = buckets[bucket_next(&state, NUM_BUCKETS)];
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 0, sizeof(cl_mem), (void *)&dev_U4_t);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 1, sizeof(cl_mem), (void *)&dev_U4_tt);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 4, 2 * sizeof(int), (void *)&q);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 5, sizeof(int), (void *)&P);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 6, sizeof(float), (void *)&sharpness);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 7, (vblocksize + 2 * P) * sizeof(float), NULL);
dt_opencl_set_kernel_args(devid, params->kernel_vert, 0, CLARG(dev_U4_t), CLARG(dev_U4_tt), CLARG(width),
CLARG(height), CLARG(q), CLARG(P), CLARG(sharpness), CLLOCAL((vblocksize + 2 * P) * sizeof(float)));
err = dt_opencl_enqueue_kernel_2d_with_local(devid, params->kernel_vert, sizesl, local);
if(err != CL_SUCCESS) break;

Expand Down Expand Up @@ -1045,20 +1022,17 @@ int nlmeans_denoiseprofile_cl(const dt_nlmeans_param_t *const params, const int

const size_t bwidth = ROUNDUP(width, hblocksize);
const size_t bheight = ROUNDUP(height, vblocksize);
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };

for(int p = 0; p < num_patches; p++)
{
const patch_t *patch = &patches[p];
int q[2] = { patch->rows, patch->cols };
const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };

// compute squared differences between input pixels and shifted (by q) pixels
cl_mem dev_U4 = buckets[bucket_next(&state, NUM_BUCKETS)];
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 1, sizeof(cl_mem), (void *)&dev_U4);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, params->kernel_dist, 4, 2 * sizeof(int), (void *)&q);
dt_opencl_set_kernel_args(devid, params->kernel_dist, 0, CLARG(dev_in), CLARG(dev_U4), CLARG(width),
CLARG(height), CLARG(q));
err = dt_opencl_enqueue_kernel_2d(devid, params->kernel_dist, sizes);
if(err != CL_SUCCESS) break;

Expand All @@ -1072,16 +1046,9 @@ int nlmeans_denoiseprofile_cl(const dt_nlmeans_param_t *const params, const int
const size_t local[3] = { 1, vblocksize, 1 };
const float central_pixel_weight = params->center_weight;
cl_mem dev_U4_tt = buckets[bucket_next(&state, NUM_BUCKETS)];
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 0, sizeof(cl_mem), (void *)&dev_U4_t);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 1, sizeof(cl_mem), (void *)&dev_U4_tt);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 4, 2 * sizeof(int), (void *)&q);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 5, sizeof(int), (void *)&P);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 6, sizeof(float), (void *)&norm);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 7, (vblocksize + 2 * P) * sizeof(float), NULL);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 8, sizeof(float), (void *)&central_pixel_weight);
dt_opencl_set_kernel_arg(devid, params->kernel_vert, 9, sizeof(cl_mem), ((void *)&dev_U4));
dt_opencl_set_kernel_args(devid, params->kernel_vert, 0, CLARG(dev_U4_t), CLARG(dev_U4_tt), CLARG(width),
CLARG(height), CLARG(q), CLARG(P), CLARG(norm), CLLOCAL((vblocksize + 2 * P) * sizeof(float)),
CLARG(central_pixel_weight), CLARG(dev_U4));
err = dt_opencl_enqueue_kernel_2d_with_local(devid, params->kernel_vert, sizesl, local);
if(err != CL_SUCCESS) break;

Expand Down
47 changes: 47 additions & 0 deletions src/common/opencl.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2289,6 +2289,41 @@ int dt_opencl_set_kernel_arg(const int dev, const int kernel, const int num, con
return (cl->dlocl->symbols->dt_clSetKernelArg)(cl->dev[dev].kernel[kernel], num, size, arg);
}

static int _opencl_set_kernel_args(const int dev, const int kernel, int num, va_list ap)
{
static struct { const size_t marker; const size_t size; const void *ptr; }
test = { CLWRAP(0, 0) };

int err = CL_SUCCESS;
do
{
size_t marker = va_arg(ap, size_t);
if(marker != test.marker)
{
fprintf(stderr, "opencl parameters passed to dt_opencl_set_kernel_args or dt_opencl_enqueue_kernel_2d_with_args must be wrapped with CLARG or CLLOCAL\n");
err = CL_INVALID_KERNEL_ARGS;
break;
}

size_t size = va_arg(ap, size_t);
if(size == SIZE_MAX) break;

void *ptr = va_arg(ap, void *);

err = dt_opencl_set_kernel_arg(dev, kernel, num++, size, ptr);
} while(!err);

va_end(ap);
return err;
}

int dt_opencl_set_kernel_args_internal(const int dev, const int kernel, const int num, ...)
{
va_list ap;
va_start(ap, num);
return _opencl_set_kernel_args(dev, kernel, num, ap);
}

int dt_opencl_enqueue_kernel_2d(const int dev, const int kernel, const size_t *sizes)
{
return dt_opencl_enqueue_kernel_2d_with_local(dev, kernel, sizes, NULL);
Expand Down Expand Up @@ -2316,6 +2351,18 @@ int dt_opencl_enqueue_kernel_2d_with_local(const int dev, const int kernel, cons
return err;
}

int dt_opencl_enqueue_kernel_2d_args_internal(const int dev, const int kernel, const size_t w, const size_t h, ...)
{
va_list ap;
va_start(ap, h);
int err = _opencl_set_kernel_args(dev, kernel, 0, ap);
if(err) return err;

const size_t sizes[] = { ROUNDUPDWD(w, dev), ROUNDUPDHT(h, dev), 1 };

return dt_opencl_enqueue_kernel_2d_with_local(dev, kernel, sizes, NULL);
}

int dt_opencl_copy_device_to_host(const int devid, void *host, void *device, const int width,
const int height, const int bpp)
{
Expand Down
24 changes: 24 additions & 0 deletions src/common/opencl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -337,13 +337,37 @@ int dt_opencl_get_kernel_work_group_size(const int dev, const int kernel, size_t
int dt_opencl_set_kernel_arg(const int dev, const int kernel, const int num, const size_t size,
const void *arg);

/** wrap opencl arguments */
/** the magic number is used for parameter checking; don't use it in your code! */
#define CLWRAP(size, ptr) (const size_t)0xF111E8, (const size_t)size, (const void *)ptr

/** wrap opencl single argument */
#define CLARG(arg) CLWRAP(sizeof(arg), &arg)

/** wrap opencl argument array */
#define CLARRAY(num, arg) CLWRAP(num * sizeof(*arg), arg)

/** wrap opencl local argument allocation */
#define CLLOCAL(arg) CLWRAP(arg, NULL)

/** attach args. */
#define dt_opencl_set_kernel_args(dev, kernel, num, ...) \
dt_opencl_set_kernel_args_internal(dev, kernel, num, __VA_ARGS__, CLWRAP(SIZE_MAX, NULL))
int dt_opencl_set_kernel_args_internal(const int dev, const int kernel, int num, ...);

/** launch kernel! */
int dt_opencl_enqueue_kernel_2d(const int dev, const int kernel, const size_t *sizes);

/** launch kernel with defined local size! */
int dt_opencl_enqueue_kernel_2d_with_local(const int dev, const int kernel, const size_t *sizes,
const size_t *local);

/** call kernel with arguments! */
#define dt_opencl_enqueue_kernel_2d_args(dev, kernel, w, h, ...) \
dt_opencl_enqueue_kernel_2d_args_internal(dev, kernel, w, h, __VA_ARGS__, CLWRAP(SIZE_MAX, NULL))
int dt_opencl_enqueue_kernel_2d_args_internal(const int dev, const int kernel,
const size_t w, const size_t h, ...);

/** check if opencl is inited */
int dt_opencl_is_inited(void);

Expand Down
2 changes: 1 addition & 1 deletion src/control/jobs/control_jobs.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2108,7 +2108,7 @@ static int _control_import_image_copy(const char *filename,
}

if(!g_file_set_contents(output, data, size, NULL))
{
{
dt_print(DT_DEBUG_CONTROL, "[import_from] failed to write file %s\n", output);
res = FALSE;
}
Expand Down
102 changes: 23 additions & 79 deletions src/develop/blend.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -706,26 +706,16 @@ static void _refine_with_detail_mask_cl(struct dt_iop_module_t *self, struct dt_
}

{
size_t sizes[3] = { ROUNDUPDWD(iwidth, devid), ROUNDUPDHT(iheight, devid), 1 };
const int kernel = darktable.opencl->blendop->kernel_read_mask;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), &out);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), &tmp);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), &iwidth);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), &iheight);
const int err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
const int err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, iwidth, iheight,
CLARG(out), CLARG(tmp), CLARG(iwidth), CLARG(iheight));
if(err != CL_SUCCESS) goto error;
}

{
size_t sizes[3] = { ROUNDUPDWD(iwidth, devid), ROUNDUPDHT(iheight, devid), 1 };
const int kernel = darktable.opencl->blendop->kernel_calc_blend;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), &out);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), &blur);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), &iwidth);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), &iheight);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(float), &threshold);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(int), &detail);
const int err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
const int err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, iwidth, iheight,
CLARG(out), CLARG(blur), CLARG(iwidth), CLARG(iheight), CLARG(threshold), CLARG(detail));
if(err != CL_SUCCESS) goto error;
}

Expand All @@ -736,14 +726,9 @@ static void _refine_with_detail_mask_cl(struct dt_iop_module_t *self, struct dt_
dev_blurmat = dt_opencl_copy_host_to_device_constant(devid, sizeof(float) * 13, blurmat);
if(dev_blurmat != NULL)
{
size_t sizes[3] = { ROUNDUPDWD(iwidth, devid), ROUNDUPDHT(iheight, devid), 1 };
const int clkernel = darktable.opencl->blendop->kernel_mask_blur;
dt_opencl_set_kernel_arg(devid, clkernel, 0, sizeof(cl_mem), &blur);
dt_opencl_set_kernel_arg(devid, clkernel, 1, sizeof(cl_mem), &out);
dt_opencl_set_kernel_arg(devid, clkernel, 2, sizeof(int), &iwidth);
dt_opencl_set_kernel_arg(devid, clkernel, 3, sizeof(int), &iheight);
dt_opencl_set_kernel_arg(devid, clkernel, 4, sizeof(cl_mem), (void *) &dev_blurmat);
const int err = dt_opencl_enqueue_kernel_2d(devid, clkernel, sizes);
const int err = dt_opencl_enqueue_kernel_2d_args(devid, clkernel, iwidth, iheight,
CLARG(blur), CLARG(out), CLARG(iwidth), CLARG(iheight), CLARG(dev_blurmat));
dt_opencl_release_mem_object(dev_blurmat);
if(err != CL_SUCCESS) goto error;
}
Expand All @@ -755,13 +740,9 @@ static void _refine_with_detail_mask_cl(struct dt_iop_module_t *self, struct dt_
}

{
size_t sizes[3] = { ROUNDUPDWD(iwidth, devid), ROUNDUPDHT(iheight, devid), 1 };
const int kernel = darktable.opencl->blendop->kernel_write_mask;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), &out);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), &tmp);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), &iwidth);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), &iheight);
const int err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
const int err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, iwidth, iheight,
CLARG(out), CLARG(tmp), CLARG(iwidth), CLARG(iheight));
if(err != CL_SUCCESS) goto error;
}

Expand Down Expand Up @@ -962,10 +943,8 @@ int dt_develop_blend_process_cl(struct dt_iop_module_t *self, struct dt_dev_pixe
// blend uniformly (no drawn or parametric mask)

// set dev_mask with global opacity value
dt_opencl_set_kernel_arg(devid, kernel_set_mask, 0, sizeof(cl_mem), (void *)&dev_mask_1);
dt_opencl_set_kernel_arg(devid, kernel_set_mask, 1, sizeof(int), (void *)&owidth);
dt_opencl_set_kernel_arg(devid, kernel_set_mask, 2, sizeof(int), (void *)&oheight);
dt_opencl_set_kernel_arg(devid, kernel_set_mask, 3, sizeof(float), (void *)&opacity);
dt_opencl_set_kernel_args(devid, kernel_set_mask, 0, CLARG(dev_mask_1), CLARG(owidth), CLARG(oheight),
CLARG(opacity));
err = dt_opencl_enqueue_kernel_2d(devid, kernel_set_mask, sizes);
if(err != CL_SUCCESS) goto error;
}
Expand Down Expand Up @@ -1051,21 +1030,10 @@ int dt_develop_blend_process_cl(struct dt_iop_module_t *self, struct dt_dev_pixe
// get parametric mask (if any) and apply global opacity
const unsigned blendif = d->blendif;
const unsigned int mask_combine = d->mask_combine;
dt_opencl_set_kernel_arg(devid, kernel_mask, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, kernel_mask, 1, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, kernel_mask, 2, sizeof(cl_mem), (void *)&dev_mask_1);
dt_opencl_set_kernel_arg(devid, kernel_mask, 3, sizeof(cl_mem), (void *)&dev_mask_2);
dt_opencl_set_kernel_arg(devid, kernel_mask, 4, sizeof(int), (void *)&owidth);
dt_opencl_set_kernel_arg(devid, kernel_mask, 5, sizeof(int), (void *)&oheight);
dt_opencl_set_kernel_arg(devid, kernel_mask, 6, sizeof(float), (void *)&opacity);
dt_opencl_set_kernel_arg(devid, kernel_mask, 7, sizeof(unsigned), (void *)&blendif);
dt_opencl_set_kernel_arg(devid, kernel_mask, 8, sizeof(cl_mem), (void *)&dev_blendif_params);
dt_opencl_set_kernel_arg(devid, kernel_mask, 9, sizeof(unsigned), (void *)&mask_mode);
dt_opencl_set_kernel_arg(devid, kernel_mask, 10, sizeof(unsigned), (void *)&mask_combine);
dt_opencl_set_kernel_arg(devid, kernel_mask, 11, 2 * sizeof(int), (void *)&offs);
dt_opencl_set_kernel_arg(devid, kernel_mask, 12, sizeof(cl_mem), (void *)&dev_profile_info);
dt_opencl_set_kernel_arg(devid, kernel_mask, 13, sizeof(cl_mem), (void *)&dev_profile_lut);
dt_opencl_set_kernel_arg(devid, kernel_mask, 14, sizeof(int), (void *)&use_profile);
dt_opencl_set_kernel_args(devid, kernel_mask, 0, CLARG(dev_in), CLARG(dev_out), CLARG(dev_mask_1),
CLARG(dev_mask_2), CLARG(owidth), CLARG(oheight), CLARG(opacity), CLARG(blendif), CLARG(dev_blendif_params),
CLARG(mask_mode), CLARG(mask_combine), CLARRAY(2, offs), CLARG(dev_profile_info), CLARG(dev_profile_lut),
CLARG(use_profile));
err = dt_opencl_enqueue_kernel_2d(devid, kernel_mask, sizes);
if(err != CL_SUCCESS)
{
Expand Down Expand Up @@ -1135,13 +1103,8 @@ int dt_develop_blend_process_cl(struct dt_iop_module_t *self, struct dt_dev_pixe
{
const float e = expf(3.f * d->contrast);
const float brightness = d->brightness;
dt_opencl_set_kernel_arg(devid, kernel_mask_tone_curve, 0, sizeof(cl_mem), (void *)&dev_mask_1);
dt_opencl_set_kernel_arg(devid, kernel_mask_tone_curve, 1, sizeof(cl_mem), (void *)&dev_mask_2);
dt_opencl_set_kernel_arg(devid, kernel_mask_tone_curve, 2, sizeof(int), (void *)&owidth);
dt_opencl_set_kernel_arg(devid, kernel_mask_tone_curve, 3, sizeof(int), (void *)&oheight);
dt_opencl_set_kernel_arg(devid, kernel_mask_tone_curve, 4, sizeof(float), (void *)&e);
dt_opencl_set_kernel_arg(devid, kernel_mask_tone_curve, 5, sizeof(float), (void *)&brightness);
dt_opencl_set_kernel_arg(devid, kernel_mask_tone_curve, 6, sizeof(float), (void *)&opacity);
dt_opencl_set_kernel_args(devid, kernel_mask_tone_curve, 0, CLARG(dev_mask_1), CLARG(dev_mask_2),
CLARG(owidth), CLARG(oheight), CLARG(e), CLARG(brightness), CLARG(opacity));
err = dt_opencl_enqueue_kernel_2d(devid, kernel_mask_tone_curve, sizes);
if(err != CL_SUCCESS) goto error;
_blend_process_cl_exchange(&dev_mask_1, &dev_mask_2);
Expand Down Expand Up @@ -1177,21 +1140,10 @@ int dt_develop_blend_process_cl(struct dt_iop_module_t *self, struct dt_dev_pixe
if(err != CL_SUCCESS) goto error;

// let us display a specific channel
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 1, sizeof(cl_mem), (void *)&dev_tmp);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 2, sizeof(cl_mem), (void *)&dev_mask_1);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 3, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 4, sizeof(int), (void *)&owidth);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 5, sizeof(int), (void *)&oheight);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 6, 2 * sizeof(int), (void *)&offs);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 7, sizeof(int), (void *)&request_mask_display);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 8, sizeof(cl_mem), (void*)&dev_boost_factors);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 9, sizeof(cl_mem), (void *)&dev_profile_info);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 10, sizeof(cl_mem), (void *)&dev_profile_lut);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 11, sizeof(int), (void *)&use_profile);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 12, sizeof(cl_mem), (void *)&dev_work_profile_info);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 13, sizeof(cl_mem), (void *)&dev_work_profile_lut);
dt_opencl_set_kernel_arg(devid, kernel_display_channel, 14, sizeof(int), (void *)&use_work_profile);
dt_opencl_set_kernel_args(devid, kernel_display_channel, 0, CLARG(dev_in), CLARG(dev_tmp), CLARG(dev_mask_1),
CLARG(dev_out), CLARG(owidth), CLARG(oheight), CLARRAY(2, offs), CLARG(request_mask_display), CLARG(dev_boost_factors),
CLARG(dev_profile_info), CLARG(dev_profile_lut), CLARG(use_profile), CLARG(dev_work_profile_info),
CLARG(dev_work_profile_lut), CLARG(use_work_profile));
err = dt_opencl_enqueue_kernel_2d(devid, kernel_display_channel, sizes);
if(err != CL_SUCCESS)
{
Expand All @@ -1204,16 +1156,8 @@ int dt_develop_blend_process_cl(struct dt_iop_module_t *self, struct dt_dev_pixe
// apply blending with per-pixel opacity value as defined in dev_mask_1
const unsigned int blend_mode = d->blend_mode;
const float blend_parameter = exp2f(d->blend_parameter);
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_tmp);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(cl_mem), (void *)&dev_mask_1);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(int), (void *)&owidth);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(int), (void *)&oheight);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(unsigned), (void *)&blend_mode);
dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(float), (void *)&blend_parameter);
dt_opencl_set_kernel_arg(devid, kernel, 8, 2 * sizeof(int), (void *)&offs);
dt_opencl_set_kernel_arg(devid, kernel, 9, sizeof(int), (void *)&mask_display);
dt_opencl_set_kernel_args(devid, kernel, 0, CLARG(dev_in), CLARG(dev_tmp), CLARG(dev_mask_1), CLARG(dev_out),
CLARG(owidth), CLARG(oheight), CLARG(blend_mode), CLARG(blend_parameter), CLARRAY(2, offs), CLARG(mask_display));
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
if(err != CL_SUCCESS) goto error;
}
Expand Down Expand Up @@ -1352,7 +1296,7 @@ void tiling_callback_blendop(struct dt_iop_module_t *self, struct dt_dev_pixelpi
if(bldata)
{
if(bldata->details != 0.0f)
tiling->factor += 0.75f; // details mask requires 3 additional quarter buffers
tiling->factor += 0.75f; // details mask requires 3 additional quarter buffers
}
}

Expand Down
1 change: 1 addition & 0 deletions src/develop/imageop.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2419,6 +2419,7 @@ void dt_iop_gui_set_expander(dt_iop_module_t *module)

GtkWidget *iopw = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
GtkWidget *expander = dtgtk_expander_new(header, iopw);
gtk_widget_set_name(expander, "iop-expander");

GtkWidget *header_evb = dtgtk_expander_get_header_event_box(DTGTK_EXPANDER(expander));
GtkWidget *body_evb = dtgtk_expander_get_body_event_box(DTGTK_EXPANDER(expander));
Expand Down
29 changes: 9 additions & 20 deletions src/develop/pixelpipe_hb.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -992,7 +992,7 @@ static int pixelpipe_process_on_CPU(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev,
{
if(!fitting)
fprintf(stderr, "[pixelpipe_process_on_CPU] [%s] Warning: processes `%s' without tiling even if memory requirements are not met\n",
dt_dev_pixelpipe_type_to_str(pipe->type), module->op);
dt_dev_pixelpipe_type_to_str(pipe->type), module->op);

dt_print(DT_DEBUG_ROI, "[process CPU] %15s %16s. IN (%4i/%4i) %4ix%4i scale=%.2f. OUT (%4i/%4i) %4ix%4i scale=%.2f\n",
dt_dev_pixelpipe_type_to_str(piece->pipe->type), module->so->op, roi_in->x, roi_in->y, roi_in->width, roi_in->height, roi_in->scale,
Expand Down Expand Up @@ -1407,15 +1407,15 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
gboolean possible_cl = (module->process_cl && piece->process_cl_ready
&& !((pipe->type & (DT_DEV_PIXELPIPE_PREVIEW | DT_DEV_PIXELPIPE_PREVIEW2)) && (module->flags() & IOP_FLAGS_PREVIEW_NON_OPENCL)));

const int m_bpp = MAX(in_bpp, bpp);
const int m_bpp = MAX(in_bpp, bpp);
const gboolean fits_on_device = dt_opencl_image_fits_device(pipe->devid, MAX(roi_in.width, roi_out->width), MAX(roi_in.height, roi_out->height),
m_bpp, required_factor_cl, tiling.overhead);

if(possible_cl && !fits_on_device)
{
if(!piece->process_tiling_ready)
possible_cl = FALSE;

const float advantage = darktable.opencl->dev[pipe->devid].advantage;
if(possible_cl && (advantage > 0.0f))
{
Expand All @@ -1425,7 +1425,7 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
{
dt_print(DT_DEBUG_OPENCL | DT_DEBUG_TILING, "[dt_dev_pixelpipetiling_cl] [%s] estimates cpu advantage in `%s', (dev=%i, adv=%.2f, GPU %.2f CPU %.2f)\n",
dt_dev_pixelpipe_type_to_str(pipe->type), module->op, pipe->devid, advantage, tilemem_cl / 1e9, tilemem_cpu / 1e9);
possible_cl = FALSE;
possible_cl = FALSE;
}
}
}
Expand Down Expand Up @@ -1771,7 +1771,7 @@ static int dt_dev_pixelpipe_process_rec(dt_dev_pixelpipe_t *pipe, dt_develop_t *
are kept. This is true
a) for the currently focused iop, as that is the iop which is most likely to change next
b) if there is a hint for a module doing heavy processing.
c) only for full or preview pipe
c) only for full or preview pipe
*/
if((module == darktable.develop->gui_module) || input_important)
{
Expand Down Expand Up @@ -2508,25 +2508,14 @@ gboolean dt_dev_write_rawdetail_mask_cl(dt_dev_pixelpipe_iop_t *piece, cl_mem in
{
wb[0] = wb[1] = wb[2] = 1.0f;
}
size_t sizes[3] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), &tmp);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), &in);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), &width);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), &height);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(float), &wb[0]);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(float), &wb[1]);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(float), &wb[2]);
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(tmp), CLARG(in), CLARG(width), CLARG(height), CLARG(wb[0]), CLARG(wb[1]), CLARG(wb[2]));
if(err != CL_SUCCESS) goto error;
}
{
size_t sizes[3] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };
const int kernel = darktable.opencl->blendop->kernel_write_scharr_mask;
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), &tmp);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), &out);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), &width);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), &height);
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
err = dt_opencl_enqueue_kernel_2d_args(devid, kernel, width, height,
CLARG(tmp), CLARG(out), CLARG(width), CLARG(height));
if(err != CL_SUCCESS) goto error;
}

Expand Down
37 changes: 23 additions & 14 deletions src/dtgtk/expander.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -82,7 +82,7 @@ void dtgtk_expander_set_expanded(GtkDarktableExpander *expander, gboolean expand
if(expanded && gtk_widget_get_mapped(GTK_WIDGET(expander)))
{
GtkWidget *sw = gtk_widget_get_parent(gtk_widget_get_parent(gtk_widget_get_parent(GTK_WIDGET(expander))));
if(GTK_IS_SCROLLED_WINDOW(sw))
if(GTK_IS_SCROLLED_WINDOW(sw) && !g_strcmp0("right", gtk_widget_get_name(gtk_widget_get_parent(sw))))
{
gtk_widget_get_allocation(GTK_WIDGET(expander), &_start_pos);
_start_pos.x = gtk_adjustment_get_value(gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sw)));
Expand All @@ -109,28 +109,32 @@ static GtkWidget *_scroll_widget = NULL;

static gboolean _expander_scroll(GtkWidget *widget, GdkFrameClock *frame_clock, gpointer user_data)
{
GtkWidget *scrolled_window = gtk_widget_get_parent(gtk_widget_get_parent(gtk_widget_get_parent(widget)));
g_return_val_if_fail(GTK_IS_SCROLLED_WINDOW(scrolled_window), G_SOURCE_REMOVE);
GtkWidget *sw = gtk_widget_get_parent(gtk_widget_get_parent(gtk_widget_get_parent(widget)));
g_return_val_if_fail(GTK_IS_SCROLLED_WINDOW(sw), G_SOURCE_REMOVE);

GtkAllocation allocation, available;
gtk_widget_get_allocation(widget, &allocation);
gtk_widget_get_allocation(scrolled_window, &available);
gtk_widget_get_allocation(sw, &available);

GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrolled_window));
GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sw));
gdouble value = gtk_adjustment_get_value(adjustment);

if(allocation.y < _start_pos.y)
const gboolean is_iop = !g_strcmp0("iop-expander", gtk_widget_get_name(widget));

// try not to get dragged upwards if a module above is collapsing
if(is_iop && allocation.y < _start_pos.y)
{
const int offset = _start_pos.y - allocation.y - _start_pos.x + value;
value -= offset;
_start_pos.y = allocation.y;
}

// scroll up if more space is needed below
// if "scroll_to_module" is enabled scroll up or down
// but don't scroll if not the whole module can be shown
float prop = 1.0f;
const gboolean scroll_to_top = dt_conf_get_bool("darkroom/ui/scroll_to_module");
const gboolean scroll_to_top = dt_conf_get_bool(is_iop ? "darkroom/ui/scroll_to_module" : "lighttable/ui/scroll_to_module");
const int spare = available.height - allocation.height;
const int from_top = allocation.y - value;
const int move = MAX(from_top - scroll_to_top ? 0 : MAX(0, MIN(from_top, spare)),
const int move = MAX(scroll_to_top ? from_top : from_top - MAX(0, MIN(from_top, spare)),
- MAX(0, spare - from_top));
if(move)
{
Expand All @@ -141,7 +145,11 @@ static gboolean _expander_scroll(GtkWidget *widget, GdkFrameClock *frame_clock,
value += prop * move;
}

_start_pos.x = value;
if(is_iop)
{
_start_pos = allocation;
_start_pos.x = value;
}
gtk_adjustment_set_value(adjustment, value);

if(prop != 1.0f) return G_SOURCE_CONTINUE;
Expand All @@ -152,9 +160,11 @@ static gboolean _expander_scroll(GtkWidget *widget, GdkFrameClock *frame_clock,

static void _expander_resize(GtkWidget *widget, GdkRectangle *allocation, gpointer user_data)
{

if(widget == _scroll_widget ||
(!(gtk_widget_get_state_flags(user_data) & GTK_STATE_FLAG_SELECTED) &&
(!darktable.lib->gui_module || darktable.lib->gui_module->expander != widget)))
((!(gtk_widget_get_state_flags(user_data) & GTK_STATE_FLAG_SELECTED) ||
gtk_widget_get_allocated_height(widget) == _start_pos.height) &&
(!darktable.lib->gui_module || darktable.lib->gui_module->expander != widget)))
return;

_scroll_widget = widget;
Expand Down Expand Up @@ -203,4 +213,3 @@ GtkWidget *dtgtk_expander_new(GtkWidget *header, GtkWidget *body)
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on

10 changes: 10 additions & 0 deletions src/imageio/format/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,16 @@ add_library(ppm MODULE "ppm.c")
add_library(pfm MODULE "pfm.c")
add_library(tiff MODULE "tiff.c")

if(JXL_FOUND)
list(APPEND MODULES "jxl_format")
add_library(jxl_format MODULE "jxl.c")
# At least on Windows, have to link to libjxl explicitly here as symbols
# from libdarktable get stripped (until read support is added). As a
# consequence, have to also change the module name to not be libjxl.
target_link_libraries(jxl_format PUBLIC ${JXL_LIBRARIES})
set_target_properties(jxl_format PROPERTIES OUTPUT_NAME jpegxl)
endif(JXL_FOUND)

if(WebP_FOUND)
list(APPEND MODULES "webp")
add_library(webp MODULE "webp.c")
Expand Down
Loading