Merge branch 'fix_varios_highlights'

TurboGit · TurboGit · commit 1793d3a0303e · 2026-01-20T18:50:06.000+01:00
* fix_varios_highlights:
  Make use of standard dt opencl kernel calling
  Fix laplacian highlights reconstruction
  Reintroduce demosaic snapping for stability
diff --git a/data/kernels/basic.cl b/data/kernels/basic.cl
@@ -833,15 +833,15 @@ interpolate_and_mask(read_only image2d_t input,
     const size_t j_prev = (j - 1);
     const size_t j_next = (j + 1);
 
-    const float north = read_imagef(input, samplerA, (int2)(j, i_prev)).x;
-    const float south = read_imagef(input, samplerA, (int2)(j, i_next)).x;
-    const float west = read_imagef(input, samplerA, (int2)(j_prev, i)).x;
-    const float east = read_imagef(input, samplerA, (int2)(j_next, i)).x;
+    const float north = read_imagef(input, sampleri, (int2)(j, i_prev)).x;
+    const float south = read_imagef(input, sampleri, (int2)(j, i_next)).x;
+    const float west = read_imagef(input, sampleri, (int2)(j_prev, i)).x;
+    const float east = read_imagef(input, sampleri, (int2)(j_next, i)).x;
 
-    const float north_east = read_imagef(input, samplerA, (int2)(j_next, i_prev)).x;
-    const float north_west = read_imagef(input, samplerA, (int2)(j_prev, i_prev)).x;
-    const float south_east = read_imagef(input, samplerA, (int2)(j_next, i_next)).x;
-    const float south_west = read_imagef(input, samplerA, (int2)(j_prev, i_next)).x;
+    const float north_east = read_imagef(input, sampleri, (int2)(j_next, i_prev)).x;
+    const float north_west = read_imagef(input, sampleri, (int2)(j_prev, i_prev)).x;
+    const float south_east = read_imagef(input, sampleri, (int2)(j_next, i_next)).x;
+    const float south_west = read_imagef(input, sampleri, (int2)(j_prev, i_next)).x;
 
     if(c == GREEN) // green pixel
     {
@@ -913,8 +913,8 @@ interpolate_and_mask(read_only image2d_t input,
     }
   }
 
-  float4 RGB = {R, G, B, dtcl_sqrt(R * R + G * G + B * B) };
-  float4 clipped = { R_clipped, G_clipped, B_clipped, (R_clipped || G_clipped || B_clipped) };
+  const float4 RGB = {R, G, B, dtcl_sqrt(R * R + G * G + B * B) };
+  const float4 clipped = { (float)R_clipped, (float)G_clipped, (float)B_clipped, (R_clipped || G_clipped || B_clipped) ? 1.0f : 0.0f };
   const float4 WB4 = { wb[0], wb[1], wb[2], wb[3] };
   write_imagef(interpolated, (int2)(j, i), RGB / WB4);
   write_imagef(clipping_mask, (int2)(j, i), clipped);
@@ -940,7 +940,7 @@ remosaic_and_replace(read_only image2d_t input,
   const int c = FC(i, j, filters);
   const float4 center = read_imagef(interpolated, sampleri, (int2)(j, i));
   float *rgb = (float *)&center;
-  const float opacity = read_imagef(clipping_mask, sampleri, (int2)(j, i)).w;
+  const float opacity = clipf(read_imagef(clipping_mask, sampleri, (int2)(j, i)).w);
   const float4 pix_in = read_imagef(input, sampleri, (int2)(j, i));
   const float4 pix_out = opacity * fmax(rgb[c] * wb[c], 0.f) + (1.f - opacity) * pix_in;
   write_imagef(output, (int2)(j, i), pix_out);
@@ -964,7 +964,7 @@ box_blur_5x5(read_only image2d_t in,
     {
       const int row = clamp(y + ii, 0, height - 1);
       const int col = clamp(x + jj, 0, width - 1);
-      acc += read_imagef(in, samplerA, (int2)(col, row)) / 25.f;
+      acc += fmax(0.0f, read_imagef(in, samplerA, (int2)(col, row))) / 25.f;
     }
 
   write_imagef(out, (int2)(x, y), acc);
diff --git a/src/iop/demosaic.c b/src/iop/demosaic.c
@@ -515,14 +515,23 @@ void modify_roi_out(dt_iop_module_t *self,
   roi_out->y = 0;
 }
 
+static inline int _snap_to_cfa(const int p, const uint32_t filters)
+{
+  const int snap = !filters ? 1 : filters != 9u ? 2 : 3;
+  return (p / snap) * snap;
+}
+
 void modify_roi_in(dt_iop_module_t *self,
                    dt_dev_pixelpipe_iop_t *piece,
                    const dt_iop_roi_t *roi_out,
                    dt_iop_roi_t *roi_in)
 {
   *roi_in = *roi_out;
-  roi_in->x = MAX(0, roi_in->x / roi_out->scale);
-  roi_in->y = MAX(0, roi_in->y / roi_out->scale);
+  // always set position to closest top/left sensor pattern snap
+  const uint32_t filters = piece->pipe->dsc.filters;
+  roi_in->x = MAX(0, _snap_to_cfa(roi_in->x / roi_out->scale, filters));
+  roi_in->y = MAX(0, _snap_to_cfa(roi_in->y / roi_out->scale, filters));
+
   roi_in->width = MAX(8, roi_in->width / roi_out->scale);
   roi_in->height = MAX(8, roi_in->height / roi_out->scale);
   roi_in->scale = 1.0f;
diff --git a/src/iop/highlights.c b/src/iop/highlights.c
@@ -583,12 +583,14 @@ int process_cl(dt_iop_module_t *self,
 
         dev_xtrans = dt_opencl_copy_host_to_device_constant(devid, sizeof(pipe->dsc.xtrans), pipe->dsc.xtrans);
         if(dev_xtrans == NULL) goto finish;
+        const int dy = roi_out->y - roi_in->y;
+        const int dx = roi_out->x - roi_in->x;
 
         err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_highlights_false_color, roi_out->width, roi_out->height,
           CLARG(dev_in), CLARG(dev_out),
           CLARG(roi_out->width), CLARG(roi_out->height),
           CLARG(roi_in->width), CLARG(roi_in->height),
-          CLARG(roi_out->x), CLARG(roi_out->y),
+          CLARG(dx), CLARG(dy),
           CLARG(filters), CLARG(dev_xtrans),
           CLARG(dev_clips));
         announce = FALSE;
diff --git a/src/iop/hlreconstruct/laplacian.c b/src/iop/hlreconstruct/laplacian.c
@@ -164,8 +164,8 @@ static void _interpolate_and_mask(const float *const restrict input,
         }
       }
 
-      dt_aligned_pixel_t RGB = { R, G, B, sqrtf(sqf(R) + sqf(G) + sqf(B)) };
-      dt_aligned_pixel_t clipped = { R_clipped, G_clipped, B_clipped, (R_clipped || G_clipped || B_clipped) };
+      const dt_aligned_pixel_t RGB = { R, G, B, sqrtf(sqf(R) + sqf(G) + sqf(B)) };
+      const dt_aligned_pixel_t clipped = { (float)R_clipped, (float)G_clipped, (float)B_clipped, (R_clipped || G_clipped || B_clipped) ? 1.0f : 0.0f };
 
       for_each_channel(k, aligned(RGB, interpolated, clipping_mask, clipped, wb))
       {
@@ -193,7 +193,7 @@ static void _remosaic_and_replace(const float *const restrict input,
       const size_t c = FC(i, j, filters);
       const size_t idx = i * width + j;
       const size_t index = idx * 4;
-      const float opacity = clipping_mask[index + ALPHA];
+      const float opacity = CLIP(clipping_mask[index + ALPHA]);
       output[idx] = opacity * fmaxf(interpolated[index + c] * wb[c], 0.f)
                     + (1.f - opacity) * input[idx];
     }
@@ -689,7 +689,6 @@ static inline cl_int wavelets_process_cl(const int devid,
                                          cl_mem in,
                                          cl_mem reconstructed,
                                          cl_mem clipping_mask,
-                                         const size_t sizes[3],
                                          const int width,
                                          const int height,
                                          dt_iop_highlights_global_data_t *const gd,
@@ -702,7 +701,7 @@ static inline cl_int wavelets_process_cl(const int devid,
                                          const int salt,
                                          const float solid_color)
 {
-  cl_int err = DT_OPENCL_DEFAULT_ERROR;
+  cl_int err = CL_SUCCESS;
 
   // À trous wavelet decompose
   // there is a paper from a guy we know that explains it : https://jo.dreggn.org/home/2010_atrous.pdf
@@ -732,21 +731,18 @@ static inline cl_int wavelets_process_cl(const int devid,
     }
 
     // Compute wavelets low-frequency scales
-    dt_opencl_set_kernel_args(devid, gd->kernel_filmic_bspline_horizontal, 0,
-      CLARG(buffer_in), CLARG(HF), CLARG(width), CLARG(height), CLARG(mult));
-    err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_filmic_bspline_horizontal, sizes);
+    err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_filmic_bspline_horizontal, width, height,
+          CLARG(buffer_in), CLARG(HF), CLARG(width), CLARG(height), CLARG(mult));
     if(err != CL_SUCCESS) return err;
 
-    dt_opencl_set_kernel_args(devid, gd->kernel_filmic_bspline_vertical, 0,
-      CLARG(HF), CLARG(buffer_out), CLARG(width), CLARG(height), CLARG(mult));
-    err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_filmic_bspline_vertical, sizes);
+    err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_filmic_bspline_vertical, width, height,
+          CLARG(HF), CLARG(buffer_out), CLARG(width), CLARG(height), CLARG(mult));
     if(err != CL_SUCCESS) return err;
 
     // Compute wavelets high-frequency scales and backup the maximum of texture over the RGB channels
     // Note : HF = detail - LF
-    dt_opencl_set_kernel_args(devid, gd->kernel_filmic_wavelets_detail, 0,
-      CLARG(buffer_in), CLARG(buffer_out), CLARG(HF), CLARG(width), CLARG(height));
-    err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_filmic_wavelets_detail, sizes);
+    err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_filmic_wavelets_detail, width, height,
+          CLARG(buffer_in), CLARG(buffer_out), CLARG(HF), CLARG(width), CLARG(height));
     if(err != CL_SUCCESS) return err;
 
     unsigned int current_scale_type = scale_type(s, scales);
@@ -755,22 +751,20 @@ static inline cl_int wavelets_process_cl(const int devid,
     // Compute wavelets low-frequency scales
     if(variant == DIFFUSE_RECONSTRUCT_RGB)
     {
-      dt_opencl_set_kernel_args(devid, gd->kernel_highlights_guide_laplacians, 0,
+      err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_highlights_guide_laplacians, width, height,
         CLARG(HF), CLARG(buffer_out), CLARG(clipping_mask),
         CLARG(reconstructed), // read-only
         CLARG(reconstructed), // write-only
         CLARG(width), CLARG(height), CLARG(mult), CLARG(noise_level), CLARG(salt), CLARG(current_scale_type), CLARG(radius));
-      err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_highlights_guide_laplacians, sizes);
       if(err != CL_SUCCESS) return err;
     }
     else // DIFFUSE_RECONSTRUCT_CHROMA
     {
-      dt_opencl_set_kernel_args(devid, gd->kernel_highlights_diffuse_color, 0,
+      err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_highlights_diffuse_color, width, height,
         CLARG(HF), CLARG(buffer_out), CLARG(clipping_mask),
         CLARG(reconstructed), // read-only
         CLARG(reconstructed), // write-only
         CLARG(width), CLARG(height), CLARG(mult), CLARG(current_scale_type), CLARG(solid_color));
-      err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_highlights_diffuse_color, sizes);
       if(err != CL_SUCCESS) return err;
     }
   }
@@ -789,7 +783,7 @@ static cl_int process_laplacian_bayer_cl(dt_iop_module_t *self,
   dt_iop_highlights_data_t *data = piece->data;
   dt_iop_highlights_global_data_t *gd = self->global_data;
 
-  cl_int err = DT_OPENCL_DEFAULT_ERROR;
+  cl_int err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
 
   const int devid = piece->pipe->devid;
   const int width = roi_in->width;
@@ -798,8 +792,8 @@ static cl_int process_laplacian_bayer_cl(dt_iop_module_t *self,
   const int ds_height = height / DS_FACTOR;
   const int ds_width = width / DS_FACTOR;
 
-  size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };
-  size_t ds_sizes[] = { ROUNDUPDWD(ds_width, devid), ROUNDUPDHT(ds_height, devid), 1 };
+  const size_t sizes[2] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid) };
+  const size_t ds_sizes[2] = { ROUNDUPDWD(ds_width, devid), ROUNDUPDHT(ds_height, devid) };
 
   const uint32_t filters = piece->pipe->dsc.filters;
 
@@ -811,6 +805,11 @@ static cl_int process_laplacian_bayer_cl(dt_iop_module_t *self,
     wb[2] = piece->pipe->dsc.temperature.coeffs[2];
   }
 
+  const float scale = fmaxf(DS_FACTOR * piece->iscale / (roi_in->scale), 1.f);
+  const float final_radius = (float)((int)(1 << data->scales)) / scale;
+  const int scales = CLAMP((int)ceilf(log2f(final_radius)), 1, MAX_NUM_SCALES);
+  const float noise_level = data->noise_level / scale;
+
   cl_mem interpolated = dt_opencl_alloc_device(devid, sizes[0], sizes[1], sizeof(float) * 4);  // [R, G, B, norm] for each pixel
   cl_mem clipping_mask = dt_opencl_alloc_device(devid, sizes[0], sizes[1], sizeof(float) * 4); // [R, G, B, norm] for each pixel
 
@@ -819,24 +818,20 @@ static cl_int process_laplacian_bayer_cl(dt_iop_module_t *self,
   cl_mem LF_even = dt_opencl_alloc_device(devid, ds_sizes[0], ds_sizes[1], sizeof(float) * 4);
   cl_mem temp = dt_opencl_alloc_device(devid, sizes[0], sizes[1], sizeof(float) * 4); // need full size here for blurring
 
-  const float scale = fmaxf(DS_FACTOR * piece->iscale / (roi_in->scale), 1.f);
-  const float final_radius = (float)((int)(1 << data->scales)) / scale;
-  const int scales = CLAMP((int)ceilf(log2f(final_radius)), 1, MAX_NUM_SCALES);
-
-  const float noise_level = data->noise_level / scale;
-
   // wavelets scales buffers
   cl_mem HF = dt_opencl_alloc_device(devid, ds_sizes[0], ds_sizes[1], sizeof(float) * 4);
   cl_mem ds_interpolated = dt_opencl_alloc_device(devid, ds_sizes[0], ds_sizes[1], sizeof(float) * 4);
   cl_mem ds_clipping_mask = dt_opencl_alloc_device(devid, ds_sizes[0], ds_sizes[1], sizeof(float) * 4);
 
   cl_mem clips_cl = dt_opencl_copy_host_to_device_constant(devid, 4 * sizeof(float), (float*)clips);
   cl_mem wb_cl = dt_opencl_copy_host_to_device_constant(devid, 4 * sizeof(float), (float*)wb);
+  if(!interpolated || !clipping_mask || !LF_odd || !LF_even || !temp || !HF
+      || !ds_interpolated || !ds_clipping_mask || !clips_cl || !wb_cl)
+    goto error;
 
   err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_highlights_bilinear_and_mask, width, height,
     CLARG(dev_in), CLARG(interpolated), CLARG(temp),
     CLARG(clips_cl), CLARG(wb_cl), CLARG(filters), CLARG(roi_out->width), CLARG(roi_out->height));
-  dt_opencl_release_mem_object(clips_cl);
   if(err != CL_SUCCESS) goto error;
 
   err = dt_opencl_enqueue_kernel_2d_args(devid, gd->kernel_highlights_box_blur, width, height,
@@ -859,11 +854,11 @@ static cl_int process_laplacian_bayer_cl(dt_iop_module_t *self,
   for(int i = 0; i < data->iterations; i++)
   {
     const int salt = (i == data->iterations - 1); // add noise on the last iteration only
-    err = wavelets_process_cl(devid, ds_interpolated, temp, ds_clipping_mask, ds_sizes, ds_width, ds_height, gd, scales, HF,
+    err = wavelets_process_cl(devid, ds_interpolated, temp, ds_clipping_mask, ds_width, ds_height, gd, scales, HF,
                               LF_odd, LF_even, DIFFUSE_RECONSTRUCT_RGB, noise_level, salt, data->solid_color);
     if(err != CL_SUCCESS) goto error;
 
-    err = wavelets_process_cl(devid, temp, ds_interpolated, ds_clipping_mask, ds_sizes, ds_width, ds_height, gd, scales, HF,
+    err = wavelets_process_cl(devid, temp, ds_interpolated, ds_clipping_mask, ds_width, ds_height, gd, scales, HF,
                               LF_odd, LF_even, DIFFUSE_RECONSTRUCT_CHROMA, noise_level, salt, data->solid_color);
     if(err != CL_SUCCESS) goto error;
   }
@@ -881,6 +876,7 @@ static cl_int process_laplacian_bayer_cl(dt_iop_module_t *self,
 
 error:
   dt_opencl_release_mem_object(wb_cl);
+  dt_opencl_release_mem_object(clips_cl);
   dt_opencl_release_mem_object(interpolated);
   dt_opencl_release_mem_object(ds_clipping_mask);
   dt_opencl_release_mem_object(ds_interpolated);
