dither.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2012-2014, 2017 Ulrich Pegelow.
    Copyright (C) 2013, 2016 johannes hanika.
    Copyright (C) 2013 Pascal de Bruijn.
    Copyright (C) 2013 Thomas Pryds.
    Copyright (C) 2013-2014, 2016, 2019 Tobias Ellinghaus.
    Copyright (C) 2014-2016, 2019 Roman Lebedev.
    Copyright (C) 2015 Pedro Côrte-Real.
    Copyright (C) 2018 Edgardo Hoszowski.
    Copyright (C) 2018, 2021 Heiko Bauke.
    Copyright (C) 2018 Maurizio Paglia.
    Copyright (C) 2018, 2020-2022 Pascal Obry.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2019 Andreas Schneider.
    Copyright (C) 2020 Aldric Renaudin.
    Copyright (C) 2020, 2022-2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020, 2022 Diederik Ter Rahe.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Philipp Lutz.
    Copyright (C) 2022 Victor Forsiuk.
    
    darktable is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    darktable is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "widgets/bauhaus.h"
#include "system/macros.h"
#include "system/openmp.h"
#include "system/target_clones.h"
#include "system/mem_alloc.h"
#include "system/simd.h"
#include "common/logging.h"
#include "common/module_versioning.h"
#include "database/database.h"
#include "common/imagebuf.h"
#include "imageio/imageio_core.h"
#include "math/math.h"
#include "common/opencl.h"
#include "pixel/tea.h"
#include "develop/develop.h"
#include "develop/imageop.h"
#include "develop/imageop_math.h"
#include "develop/imageop_gui.h"
 
#include "gui/presets.h"
#include "iop/iop_api.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
 
#include <gtk/gtk.h>
#include <inttypes.h>
 
DT_MODULE_INTROSPECTION(1, dt_iop_dither_params_t)
 
typedef enum dt_iop_dither_type_t
{
  DITHER_RANDOM,      // $DESCRIPTION: "random"
  DITHER_FS1BIT,      // $DESCRIPTION: "Floyd-Steinberg 1-bit B&W"
  DITHER_FS4BIT_GRAY, // $DESCRIPTION: "Floyd-Steinberg 4-bit gray"
  DITHER_FS8BIT,      // $DESCRIPTION: "Floyd-Steinberg 8-bit RGB"
  DITHER_FS16BIT,     // $DESCRIPTION: "Floyd-Steinberg 16-bit RGB"
  DITHER_FSAUTO       // $DESCRIPTION: "Floyd-Steinberg auto"
} dt_iop_dither_type_t;
 
 
typedef struct dt_iop_dither_params_t
{
  dt_iop_dither_type_t dither_type; // $DEFAULT: DITHER_FSAUTO $DESCRIPTION: "method"
  int palette; // reserved for future extensions
  struct
  {
    float radius;   // reserved for future extensions
    float range[4]; // reserved for future extensions {0,0,1,1}
    float damping;  // $MIN: -200.0 $MAX: 0.0 $DEFAULT: -200.0 $DESCRIPTION: "damping"
  } random;
} dt_iop_dither_params_t;
 
typedef struct dt_iop_dither_gui_data_t
{
  GtkWidget *dither_type;
  GtkWidget *random;
  GtkWidget *radius;
  GtkWidget *range;
  GtkWidget *range_label;
  GtkWidget *damping;
} dt_iop_dither_gui_data_t;
 
typedef struct dt_iop_dither_data_t
{
  dt_iop_dither_type_t dither_type;
  struct
  {
    float radius;
    float range[4];
    float damping;
  } random;
} dt_iop_dither_data_t;
 
typedef struct dt_iop_dither_global_data_t
{
  int kernel_dither_random;
} dt_iop_dither_global_data_t;
 
 
const char *name()
{
  return _("dithering");
}
 
const char **description(struct dt_iop_module_t *self)
{
  return dt_iop_set_description(self, _("reduce banding and posterization effects in output JPEGs by adding random noise"),
                                      _("corrective"),
                                      _("non-linear, RGB, display-referred"),
                                      _("non-linear, RGB"),
                                      _("non-linear, RGB, display-referred"));
}
 
int default_group()
{
  return IOP_GROUP_TECHNICAL;
}
 
int flags()
{
  return IOP_FLAGS_ONE_INSTANCE;
}
 
int default_colorspace(dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece)
{
  return IOP_CS_RGB_DISPLAY;
}
 
void init_presets(dt_iop_module_so_t *self)
{
  dt_database_start_transaction();
 
  dt_iop_dither_params_t tmp
      = (dt_iop_dither_params_t){ DITHER_FSAUTO, 0, { 0.0f, { 0.0f, 0.0f, 1.0f, 1.0f }, -200.0f } };
  // add the preset.
  dt_gui_presets_add_generic(_("dither"), self->op,
                             self->version(), &tmp, sizeof(dt_iop_dither_params_t), 1);
  // make it auto-apply for all images:
  // dt_gui_presets_update_autoapply(_("dither"), self->op, self->version(), 1);
 
  dt_database_release_transaction();
}
 
 
void reload_defaults(dt_iop_module_t *module)
{
  // Auto-enable for safe JPEG export
  module->default_enabled = TRUE;
}
 
 
__OMP_DECLARE_SIMD__(simdlen(4))
static inline float _quantize(const float val, const float f, const float rf)
{
  return rf * ceilf((val * f) - 0.5); // round up only if frac(x) strictly greater than 0.5
  //originally (and more slowly):
  //const float tmp = val * f;
  //const float itmp = floorf(tmp);
  //return rf * (itmp + ((tmp - itmp > 0.5f) ? 1.0f : 0.0f));
}
 
__OMP_DECLARE_SIMD__()
static inline float _rgb_to_gray(const float *const restrict val)
{
  return 0.30f * val[0] + 0.59f * val[1] + 0.11f * val[2]; // RGB -> GRAY
}
 
__OMP_DECLARE_SIMD__()
static inline void nearest_color(float *const restrict val, float *const restrict err, int graymode,
                                 const float f, const float rf)
{
  if (graymode)
  {
    // dither pixel into gray, with f=levels-1 and rf=1/f, return err=old-new
    const float in = _rgb_to_gray(val);
    const float new = _quantize(in,f,rf);
    __OMP_SIMD__(aligned(val, err : 16))
    for(int c = 0; c < 4; c++)
    {
      err[c] = val[c] - new;
      val[c] = new;
    }
  }
  else
  {
    // dither pixel into RGB, with f=levels-1 and rf=1/f, return err=old-new
  __OMP_SIMD__(aligned(val, err : 16))
  for(int c = 0; c < 4; c++)
  {
    const float old = val[c];
    const float new = _quantize(old, f, rf);
    err[c] = old - new;
    val[c] = new;
  }
  }
}
 
static inline void _diffuse_error(float *const restrict val, const float *const restrict err, const float factor)
{
  __OMP_SIMD__(aligned(val, err))
  for(int c = 0; c < 4; c++)
  {
    val[c] += err[c] * factor;
  }
}
 
#if defined(__x86_64__) || defined(__i386__)
static inline void _diffuse_error_sse(float *val, const __m128 err, const float factor)
{
  _mm_store_ps(val, _mm_load_ps(val) + (err * _mm_set1_ps(factor))); // *val += err * factor
}
#endif
 
__OMP_DECLARE_SIMD__()
static inline float clipnan(const float x)
{
  // convert NaN to 0.5, otherwise clamp to between 0.0 and 1.0
  return (x > 0.0f) ? ((x < 1.0f) ? x    // 0 < x < 1
                                  : 1.0f // x >= 1
                       )
         : isnan(x) ? 0.5f  // x is NaN
                    : 0.0f; // x <= 0
}
 
static inline void clipnan_pixel(float *const restrict out, const float *const restrict in)
{
  __OMP_SIMD__(aligned(in, out : 16))
  for (int c = 0; c < 4; c++)
    out[c] = clipnan(in[c]);
}
 
// clipnan_pixel proves to vectorize just fine, so don't bother implementing a separate SSE version
#define clipnan_pixel_sse clipnan_pixel
 
static inline __attribute__((always_inline)) int get_dither_parameters(const dt_iop_dither_data_t *const data, const dt_dev_pixelpipe_t *const pipe,
                                 const dt_dev_pixelpipe_iop_t *const piece,
                                 const float scale, unsigned int *const restrict levels)
{
  int graymode = -1;
  *levels = 65536;
  const int l1 = floorf(1.0f + dt_log2f(1.0f / scale));
  const int bds = (pipe->type != DT_DEV_PIXELPIPE_EXPORT) ? l1 * l1 : 1;
 
  switch(data->dither_type)
  {
    case DITHER_FS1BIT:
      graymode = 1;
      *levels = MAX(2, MIN(bds + 1, 256));
      break;
    case DITHER_FS4BIT_GRAY:
      graymode = 1;
      *levels = MAX(16, MIN(15 * bds + 1, 256));
      break;
    case DITHER_FS8BIT:
      graymode = 0;
      *levels = 256;
      break;
    case DITHER_FS16BIT:
      graymode = 0;
      *levels = 65536;
      break;
    case DITHER_FSAUTO:
      switch(pipe->levels & IMAGEIO_CHANNEL_MASK)
      {
        case IMAGEIO_RGB:
          graymode = 0;
          break;
        case IMAGEIO_GRAY:
          graymode = 1;
          break;
      }
 
      switch(pipe->levels & IMAGEIO_PREC_MASK)
      {
        case IMAGEIO_INT8:
          *levels = 256;
          break;
        case IMAGEIO_INT12:
          *levels = 4096;
          break;
        case IMAGEIO_INT16:
          *levels = 65536;
          break;
        case IMAGEIO_BW:
          *levels = 2;
          break;
        case IMAGEIO_INT32:
        case IMAGEIO_FLOAT:
        default:
          graymode = -1;
          break;
      }
      break;
    case DITHER_RANDOM:
      // this function won't ever be called for that type
      // instead, process_random() will be called
      __builtin_unreachable();
      break;
  }
  return graymode;
}
 
// what fraction of the error to spread to each neighbor pixel
#define RIGHT_WT      (7.0f/16.0f)
#define DOWNRIGHT_WT  (1.0f/16.0f)
#define DOWN_WT       (5.0f/16.0f)
#define DOWNLEFT_WT   (3.0f/16.0f)
__DT_CLONE_TARGETS__
static void process_floyd_steinberg(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                                    const dt_dev_pixelpipe_iop_t *piece, const void *const ivoid, void *const ovoid,
                                    const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
  const dt_iop_dither_data_t *const restrict data = (dt_iop_dither_data_t *)piece->data;
 
  const int width = roi_in->width;
  const int height = roi_in->height;
  const float scale = roi_in->scale;
 
  const float *const restrict in = (const float *)ivoid;
  float *const restrict out = (float *)ovoid;
 
  unsigned int levels = 1;
  int graymode = get_dither_parameters(data, pipe, piece, scale, &levels);
  if(graymode < 0)
  {
    // No determinable quantization for this output: pass the buffer through UNTOUCHED.
    // (Float/int32 outputs never even reach here: commit_params() disables the module for
    // them. The historical clipnan_pixel() pass here clamped to [0,1], which destroyed the
    // HDR values of every float/EXR export.)
    dt_iop_image_copy_by_size(ovoid, ivoid, width, height, 4);
    return;
  }
 
  const float f = levels - 1;
  const float rf = 1.0 / f;
  dt_aligned_pixel_t err;
 
  // dither without error diffusion on very tiny images
  if(width < 3 || height < 3)
  {
    for(int j = 0; j < height * width; j++)
    {
      clipnan_pixel(out + 4 * j, in + 4 * j);
      nearest_color(out + 4 * j, err, graymode, f, rf);
    }
 
    if(pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK)
      dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
    return;
  }
 
  // offsets to neighboring pixels
  const size_t right = 4;
  const size_t downleft = 4 * (width-1);
  const size_t down = 4 * width;
  const size_t downright = 4 * (width+1);
 
#define PROCESS_PIXEL_FULL(_pixel, inpix)                               \
  {                                                                     \
    float *const pixel_ = (_pixel);                                     \
    nearest_color(pixel_, err, graymode, f, rf);              /* quantize pixel */ \
    clipnan_pixel(pixel_ + downright,(inpix) + downright);    /* prepare downright for first access */ \
    _diffuse_error(pixel_ + right, err, RIGHT_WT);            /* diffuse quantization error to neighbors */ \
    _diffuse_error(pixel_ + downleft, err, DOWNLEFT_WT);                \
    _diffuse_error(pixel_ + down, err, DOWN_WT);                        \
    _diffuse_error(pixel_ + downright, err, DOWNRIGHT_WT);              \
  }
 
#define PROCESS_PIXEL_LEFT(_pixel, inpix)                               \
  {                                                                     \
    float *const pixel_ = (_pixel);                                     \
    nearest_color(pixel_, err, graymode, f, rf);              /* quantize pixel */ \
    clipnan_pixel(pixel_ + down,(inpix) + down);              /* prepare down for first access */ \
    clipnan_pixel(pixel_ + downright,(inpix) + downright);    /* prepare downright for first access */ \
    _diffuse_error(pixel_ + right, err, RIGHT_WT);            /* diffuse quantization error to neighbors */ \
    _diffuse_error(pixel_ + down, err, DOWN_WT);                        \
    _diffuse_error(pixel_ + downright, err, DOWNRIGHT_WT);              \
  }
 
#define PROCESS_PIXEL_RIGHT(pixel)                                      \
  nearest_color(pixel, err, graymode, f, rf);             /* quantize pixel */ \
  _diffuse_error(pixel + downleft, err, DOWNLEFT_WT);     /* diffuse quantization error to neighbors */ \
  _diffuse_error(pixel + down, err, DOWN_WT);
 
  // once the FS dithering gets started, we can copy&clip the downright pixel, as that will be the first time
  // it will be accessed.  But to get the process started, we need to prepare the top row of pixels
  __OMP_SIMD__(aligned(in, out : 64))
  for (int j = 0; j < width; j++)
  {
    clipnan_pixel(out + 4*j, in + 4*j);
  }
 
  // floyd-steinberg dithering follows here
  // do the bulk of the image (all except the last row)
  for(int j = 0; j < height - 1; j++)
  {
    const float *const restrict inrow = in + (size_t)4 * j * width;
    float *const restrict outrow = out + (size_t)4 * j * width;
 
    // first two columns
    PROCESS_PIXEL_LEFT(outrow, inrow);                          // leftmost pixel in first (upper) row
 
    // main part of the current row
    for(int i = 1; i < width - 1; i++)
    {
      PROCESS_PIXEL_FULL(outrow + 4 * i, inrow + 4 * i);
    }
 
    // last column of upper row
    PROCESS_PIXEL_RIGHT(outrow + 4 * (width-1));
  }
 
  // final row
  {
    float *const restrict outrow = out + (size_t)4 * (height - 1) * width;
 
    // last row except for the right-most pixel
    for(int i = 0; i < width - 1; i++)
    {
      float *const restrict pixel = outrow + 4 * i;
      nearest_color(pixel, err, graymode, f, rf);              // quantize the pixel
      _diffuse_error(pixel + right, err, RIGHT_WT);            // spread error to only remaining neighbor
    }
 
    // lower right pixel
    nearest_color(outrow + 4 * (width - 1), err, graymode, f, rf);  // quantize the last pixel, no neighbors left
  }
 
  // copy alpha channel if needed
  if(pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK)
    dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
 
__DT_CLONE_TARGETS__
static void process_random(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                           const dt_dev_pixelpipe_iop_t *piece, const void *const ivoid, void *const ovoid,
                           const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
  const dt_iop_dither_data_t *const data = (dt_iop_dither_data_t *)piece->data;
 
  const int width = roi_in->width;
  const int height = roi_in->height;
  const float dither = powf(2.0f, data->random.damping / 10.0f);
 
  unsigned int *const tea_states = alloc_tea_states(dt_get_num_openmp_threads());
  __OMP_PARALLEL__()
  {
    // get a pointer to each thread's private buffer *outside* the for loop, to avoid a function call per iteration
    unsigned int *const tea_state = get_tea_state(tea_states,dt_get_thread_num());
    __OMP_FOR__()
    for(int j = 0; j < height; j++)
    {
      const size_t k = (size_t)4 * width * j;
      const float *const in = (const float *)ivoid + k;
      float *const out = (float *)ovoid + k;
      tea_state[0] = j * height; /* + dt_get_thread_num() -- do not include, makes results unreproducible */
      for(int i = 0; i < width; i++)
      {
        encrypt_tea(tea_state);
        float dith = dither * tpdf(tea_state[0]);
        __OMP_SIMD__(aligned(in, out : 64))
        for(int c = 0; c < 4; c++)
        {
          out[4*i+c] = CLIP(in[4*i+c] + dith);
        }
      }
    }
  }
  free_tea_states(tea_states);
 
  if(pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) dt_iop_alpha_copy(ivoid, ovoid, width, height);
}
 
 
int process(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
             void *const ovoid)
{
  const dt_iop_roi_t *const roi_in = &piece->roi_in;
  const dt_iop_roi_t *const roi_out = &piece->roi_out;
  dt_iop_dither_data_t *data = (dt_iop_dither_data_t *)piece->data;
 
  if(data->dither_type == DITHER_RANDOM)
    process_random(self, pipe, piece, ivoid, ovoid, roi_in, roi_out);
  else
  {
    process_floyd_steinberg(self, pipe, piece, ivoid, ovoid, roi_in, roi_out);
  }
  return 0;
}
 
#ifdef HAVE_OPENCL
int process_cl(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out)
{
  const dt_iop_roi_t *const roi_in = &piece->roi_in;
  const dt_iop_dither_data_t *const d = (dt_iop_dither_data_t *)piece->data;
  dt_iop_dither_global_data_t *const gd = (dt_iop_dither_global_data_t *)self->global_data;
  cl_mem dev_work = NULL;
 
  const int width = roi_in->width;
  const int height = roi_in->height;
  const int devid = pipe->devid;
  const int preserve_alpha = (pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) ? 1 : 0;
  cl_int err = CL_SUCCESS;
  size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };
 
  if(d->dither_type == DITHER_RANDOM)
  {
    const float dither = powf(2.0f, d->random.damping / 10.0f);
    dt_opencl_set_kernel_arg(devid, gd->kernel_dither_random, 0, sizeof(cl_mem), (void *)&dev_in);
    dt_opencl_set_kernel_arg(devid, gd->kernel_dither_random, 1, sizeof(cl_mem), (void *)&dev_out);
    dt_opencl_set_kernel_arg(devid, gd->kernel_dither_random, 2, sizeof(int), (void *)&width);
    dt_opencl_set_kernel_arg(devid, gd->kernel_dither_random, 3, sizeof(int), (void *)&height);
    dt_opencl_set_kernel_arg(devid, gd->kernel_dither_random, 4, sizeof(float), (void *)&dither);
    dt_opencl_set_kernel_arg(devid, gd->kernel_dither_random, 5, sizeof(int), (void *)&preserve_alpha);
 
    err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_dither_random, sizes);
    if(err != CL_SUCCESS) goto error;
    return TRUE;
  }
 
error:
  dt_opencl_release_mem_object(dev_work);
  dt_print(DT_DEBUG_OPENCL, "[opencl_dither] couldn't enqueue kernel! %d\n", err);
  return FALSE;
}
#endif
 
void gui_changed(dt_iop_module_t *self, GtkWidget *w, void *previous)
{
  dt_iop_dither_params_t *p = (dt_iop_dither_params_t *)self->params;
  dt_iop_dither_gui_data_t *g = (dt_iop_dither_gui_data_t *)dt_iop_gui_data(self);
 
  if(w == g->dither_type)
  {
    gtk_widget_set_visible(g->random, p->dither_type == DITHER_RANDOM);
  }
}
 
#if 0
static void
radius_callback (GtkWidget *slider, gpointer user_data)
{
  dt_iop_module_t *self = (dt_iop_module_t *)user_data;
  if(dt_gui_widgets_suppressed()) return;
  dt_iop_dither_params_t *p = (dt_iop_dither_params_t *)self->params;
  p->random.radius = dt_bauhaus_slider_get(slider);
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
#endif
 
#if 0
static void
range_callback (GtkWidget *slider, gpointer user_data)
{
  dt_iop_module_t *self = (dt_iop_module_t *)user_data;
  if(dt_gui_widgets_suppressed()) return;
  dt_iop_dither_params_t *p = (dt_iop_dither_params_t *)self->params;
  p->random.range[0] = dtgtk_gradient_slider_multivalue_get_value(DTGTK_GRADIENT_SLIDER(slider), 0);
  p->random.range[1] = dtgtk_gradient_slider_multivalue_get_value(DTGTK_GRADIENT_SLIDER(slider), 1);
  p->random.range[2] = dtgtk_gradient_slider_multivalue_get_value(DTGTK_GRADIENT_SLIDER(slider), 2);
  p->random.range[3] = dtgtk_gradient_slider_multivalue_get_value(DTGTK_GRADIENT_SLIDER(slider), 3);
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
#endif
 
void commit_params(struct dt_iop_module_t *self, dt_iop_params_t *p1, dt_dev_pixelpipe_t *pipe,
                   dt_dev_pixelpipe_iop_t *piece)
{
  dt_iop_dither_params_t *p = (dt_iop_dither_params_t *)p1;
  dt_iop_dither_data_t *d = (dt_iop_dither_data_t *)piece->data;
 
  d->dither_type = p->dither_type;
  memcpy(&(d->random.range), &(p->random.range), sizeof(p->random.range));
  d->random.radius = p->random.radius;
  d->random.damping = p->random.damping;
 
  // Dithering quantizes to integer levels: on floating-point (or int32) outputs it is
  // meaningless whatever the dither type, so disable the node entirely. Its passthrough
  // paths used to clamp every float/EXR export to [0,1], destroying HDR values (e.g.
  // reconstructed highlights above the white point).
  const int prec = pipe->levels & IMAGEIO_PREC_MASK;
 
  if(prec == IMAGEIO_FLOAT || prec == IMAGEIO_INT32)
    piece->enabled = FALSE;
 
  // Floyd-Steinberg can't run on OpenCL because it's a super-serial algo
  // But it's still slow on CPU
  if(dt_dev_pixelpipe_get_realtime(pipe))
    piece->enabled = FALSE;
  else if (d->dither_type != DITHER_RANDOM)
    piece->process_cl_ready = FALSE;
}
 
void init_pipe(struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  piece->data = dt_calloc_align(sizeof(dt_iop_dither_data_t));
  piece->data_size = sizeof(dt_iop_dither_data_t);
}
 
void cleanup_pipe(struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  dt_free_align(piece->data);
  piece->data = NULL;
}
 
void init_global(dt_iop_module_so_t *module)
{
  const int program = 8; // extended.cl, from programs.conf
  dt_iop_dither_global_data_t *gd = (dt_iop_dither_global_data_t *)calloc(1, sizeof(dt_iop_dither_global_data_t));
  if(IS_NULL_PTR(gd)) return;
  module->data = gd;
  gd->kernel_dither_random = dt_opencl_create_kernel(program, "dither_random");
}
 
void cleanup_global(dt_iop_module_so_t *module)
{
  dt_iop_dither_global_data_t *gd = (dt_iop_dither_global_data_t *)module->data;
  dt_opencl_free_kernel(gd->kernel_dither_random);
  dt_free(module->data);
}
 
 
void gui_update(struct dt_iop_module_t *self)
{
  dt_iop_dither_gui_data_t *g = (dt_iop_dither_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_dither_params_t *p = (dt_iop_dither_params_t *)self->params;
#if 0
  dt_bauhaus_slider_set(g->radius, p->random.radius);
 
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[0], 0);
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[1], 1);
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[2], 2);
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[3], 3);
#endif
 
  gtk_widget_set_visible(g->random, p->dither_type == DITHER_RANDOM);
}
 
void gui_init(struct dt_iop_module_t *self)
{
  dt_iop_dither_gui_data_t *g = IOP_GUI_ALLOC(dither);
 
  g->random = self->gui->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
#if 0
  g->radius = dt_bauhaus_slider_new_with_range(dt_bauhaus_get_global(), DT_GUI_MODULE(self), 0.0, 200.0, 0.1, p->random.radius, 2);
  gtk_widget_set_tooltip_text(g->radius, _("radius for blurring step"));
  dt_bauhaus_widget_set_label(g->radius, N_("radius"));
 
  g->range = dtgtk_gradient_slider_multivalue_new(4);
  dtgtk_gradient_slider_multivalue_set_marker(DTGTK_GRADIENT_SLIDER(g->range), GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 0);
  dtgtk_gradient_slider_multivalue_set_marker(DTGTK_GRADIENT_SLIDER(g->range), GRADIENT_SLIDER_MARKER_UPPER_FILLED_BIG, 1);
  dtgtk_gradient_slider_multivalue_set_marker(DTGTK_GRADIENT_SLIDER(g->range), GRADIENT_SLIDER_MARKER_UPPER_FILLED_BIG, 2);
  dtgtk_gradient_slider_multivalue_set_marker(DTGTK_GRADIENT_SLIDER(g->range), GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 3);
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[0], 0);
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[1], 1);
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[2], 2);
  dtgtk_gradient_slider_multivalue_set_value(DTGTK_GRADIENT_SLIDER(g->range), p->random.range[3], 3);
  gtk_widget_set_tooltip_text(g->range, _("the gradient range where to apply random dither"));
  g->range_label = gtk_label_new(_("gradient range"));
 
  GtkWidget *rlabel = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(rlabel), GTK_WIDGET(g->range_label), FALSE, FALSE, 0);
#endif
 
  g->damping = dt_bauhaus_slider_from_params(self, "random.damping");
 
  gtk_widget_set_tooltip_text(g->damping, _("damping level of random dither"));
  dt_bauhaus_slider_set_digits(g->damping, 3);
  dt_bauhaus_slider_set_format(g->damping, " dB");
 
#if 0
  gtk_box_pack_start(GTK_BOX(g->random), g->radius, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(g->random), rlabel, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(g->random), g->range, TRUE, TRUE, 0);
#endif
 
  self->gui->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  g->dither_type = dt_bauhaus_combobox_from_params(self, "dither_type");
 
  gtk_box_pack_start(GTK_BOX(self->gui->widget), g->random, TRUE, TRUE, 0);
 
#if 0
  g_signal_connect (G_OBJECT (g->radius), "value-changed",
                    G_CALLBACK (radius_callback), self);
  g_signal_connect (G_OBJECT (g->range), "value-changed",
                    G_CALLBACK (range_callback), self);
#endif
}
 
// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// 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