gamma.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2012 johannes hanika.
    Copyright (C) 2010-2011 Bruce Guenter.
    Copyright (C) 2010-2011 Henrik Andersson.
    Copyright (C) 2010 José Carlos García Sogo.
    Copyright (C) 2010 Pascal de Bruijn.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012, 2014, 2017 Ulrich Pegelow.
    Copyright (C) 2013, 2020 Aldric Renaudin.
    Copyright (C) 2013-2014, 2016-2017, 2019 Tobias Ellinghaus.
    Copyright (C) 2014-2016 Roman Lebedev.
    Copyright (C) 2015 Pedro Côrte-Real.
    Copyright (C) 2018, 2020, 2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2018-2019 Edgardo Hoszowski.
    Copyright (C) 2019 Andreas Schneider.
    Copyright (C) 2020 Diederik Ter Rahe.
    Copyright (C) 2020 Harold le Clément de Saint-Marcq.
    Copyright (C) 2020-2021 Pascal Obry.
    Copyright (C) 2021 Ralf Brown.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Philipp Lutz.
    
    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 "system/mem_alloc.h"
#include "common/conf.h"
#include "common/module_versioning.h"
#include "common/logging.h"
#include "system/openmp.h"
#include "system/simd.h"
#include "system/target_clones.h"
#include "config.h"
#endif
#include "develop/imageop_gui.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
 
#include "common/colorspaces_inline_conversions.h"
#include "common/opencl.h"
#include "develop/develop.h"
 
#include "iop/iop_api.h"
#include "widgets/widget_settings.h"
 
DT_MODULE_INTROSPECTION(1, dt_iop_gamma_params_t)
 
 
typedef struct dt_iop_gamma_params_t
{
  float gamma, linear;
} dt_iop_gamma_params_t;
 
#ifdef HAVE_OPENCL
typedef struct dt_iop_gamma_global_data_t
{
  int kernel_gamma_pack;
} dt_iop_gamma_global_data_t;
 
typedef enum dt_iop_gamma_kernel_mode_t
{
  DT_IOP_GAMMA_KERNEL_COPY = 0,
  DT_IOP_GAMMA_KERNEL_MASK = 1,
  DT_IOP_GAMMA_KERNEL_CHANNEL_MONO = 2,
  DT_IOP_GAMMA_KERNEL_CHANNEL_FALSE_COLOR = 3
} dt_iop_gamma_kernel_mode_t;
 
typedef enum dt_iop_gamma_false_color_t
{
  DT_IOP_GAMMA_FALSE_COLOR_MONO = 0,
  DT_IOP_GAMMA_FALSE_COLOR_A = 1,
  DT_IOP_GAMMA_FALSE_COLOR_B = 2,
  DT_IOP_GAMMA_FALSE_COLOR_R = 3,
  DT_IOP_GAMMA_FALSE_COLOR_G = 4,
  DT_IOP_GAMMA_FALSE_COLOR_B_CH = 5,
  DT_IOP_GAMMA_FALSE_COLOR_C = 6,
  DT_IOP_GAMMA_FALSE_COLOR_LCH_H = 7,
  DT_IOP_GAMMA_FALSE_COLOR_HSL_H = 8,
  DT_IOP_GAMMA_FALSE_COLOR_JZ_HZ = 9
} dt_iop_gamma_false_color_t;
#endif
 
const char *name()
{
  return C_("modulename", "display encoding");
}
 
int default_group()
{
  return IOP_GROUP_TECHNICAL;
}
 
int flags()
{
  return IOP_FLAGS_HIDDEN | IOP_FLAGS_ONE_INSTANCE | IOP_FLAGS_UNSAFE_COPY | IOP_FLAGS_NO_HISTORY_STACK;
}
 
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 input_format(dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece,
                  dt_iop_buffer_dsc_t *dsc)
{
  default_input_format(self, pipe, piece, dsc);
  dsc->channels = 4;
  dsc->datatype = TYPE_FLOAT;
}
 
void output_format(dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece,
                   dt_iop_buffer_dsc_t *dsc)
{
  dsc->channels = 4;
  dsc->datatype = TYPE_UINT8;
  dsc->cst = self->default_colorspace(self, pipe, piece);
}
 
 
typedef struct dt_iop_gamma_mask_preview_t
{
  dt_aligned_pixel_t checker_color_1;
  dt_aligned_pixel_t checker_color_2;
  size_t checker_1;
  size_t checker_2;
  size_t width;
  gboolean black_and_white;
} dt_iop_gamma_mask_preview_t;
 
typedef struct dt_iop_gamma_data_t
{
  dt_iop_gamma_mask_preview_t preview;
  gboolean false_color;
} dt_iop_gamma_data_t;
 
__OMP_DECLARE_SIMD__(uniform(preview))
static inline void _write_pixel(const float *const restrict in, uint8_t *const restrict out,
                                const dt_iop_gamma_mask_preview_t *const preview,
                                const size_t pixel_index, const float alpha)
{
  // Blend the image with the checker in linear RGB, then encode the result once.
  const size_t y = pixel_index / preview->width;
  const size_t x = pixel_index - y * preview->width;
  const gboolean first_x = x % preview->checker_1 < x % preview->checker_2;
  const gboolean first_y = y % preview->checker_1 < y % preview->checker_2;
  const float *const checker_color
      = first_x == first_y ? preview->checker_color_2 : preview->checker_color_1;
  dt_aligned_pixel_t pixel;
  for(size_t c = 0; c < 3; c++)
  {
    const float value = in[c] * (1.0f - alpha) + checker_color[c] * alpha;
    pixel[c] = value <= 0.0031308f ? 12.92f * value
                                  : (1.0f + 0.055f) * powf(value, 1.0f / 2.4f) - 0.055f;
  }
 
  // the output of this module is BGR(A) instead of RGBA; can't use for_each_channel here due to the index swap
  for(size_t c = 0; c < 3; c++)
  {
    const float value = roundf(255.0f * pixel[c]);
    out[2 - c] = (uint8_t)(fminf(fmaxf(value, 0.0f), 255.0f));
  }
}
__OMP_DECLARE_SIMD__(aligned(pixel: 16) uniform(norm))
static inline __attribute__((always_inline)) void _normalize_color(float *const restrict pixel, const float norm)
{
  // color may not be black!
  const float factor = norm / fmaxf(pixel[0], fmaxf(pixel[1], pixel[2]));
  for_each_channel(x)
    pixel[x] *= factor;
}
 
__OMP_DECLARE_SIMD__(aligned(XYZ, sRGB: 16) uniform(norm))
static inline void _XYZ_to_REC_709_normalized(const float *const restrict XYZ, float *const restrict sRGB,
                                                  const float norm)
{
  dt_XYZ_to_Rec709_D50(XYZ, sRGB);
  _normalize_color(sRGB, norm);
}
__DT_CLONE_TARGETS__
static void _channel_display_monochrome(const float *const restrict in, uint8_t *const restrict out,
                                        const size_t buffsize, const float alpha,
                                        const dt_iop_gamma_mask_preview_t *const preview)
{
  // Render each selected channel value as a neutral image over the shared mask checkerboard.
  __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
  for(size_t j = 0; j < buffsize; j += 4)
  {
    dt_aligned_pixel_t pixel = { in[j + 1], in[j + 1], in[j + 1], in[j + 1] };
    _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
  }
}
__DT_CLONE_TARGETS__
static void _channel_display_false_color(const float *const restrict in, uint8_t *const restrict out,
                                         const size_t buffsize, const float alpha,
                                         dt_dev_pixelpipe_display_mask_t channel,
                                         const dt_iop_gamma_mask_preview_t *const preview)
{
  switch(channel & DT_DEV_PIXELPIPE_DISPLAY_ANY & ~DT_DEV_PIXELPIPE_DISPLAY_OUTPUT)
  {
    case DT_DEV_PIXELPIPE_DISPLAY_a:
      __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
      for(size_t j = 0; j < buffsize; j += 4)
      {
        dt_aligned_pixel_t xyz;
        dt_aligned_pixel_t pixel;
        // colors with "a" exceeding the range [-56,56] range will yield colors not representable in sRGB
        const float value = fminf(fmaxf(in[j + 1] * 256.0f - 128.0f, -56.0f), 56.0f);
        const dt_aligned_pixel_t lab = { 79.0f - value * (11.0f / 56.0f), value, 0.0f, 0.0f };
        dt_Lab_to_XYZ(lab, xyz);
        _XYZ_to_REC_709_normalized(xyz, pixel, 0.75f);
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_b:
      __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
      for(size_t j = 0; j < buffsize; j += 4)
      {
        dt_aligned_pixel_t xyz, pixel;
        // colors with "b" exceeding the range [-65,65] range will yield colors not representable in sRGB
        const float value = fminf(fmaxf(in[j + 1] * 256.0f - 128.0f, -65.0f), 65.0f);
        const dt_aligned_pixel_t lab = { 60.0f + value * (2.0f / 65.0f), 0.0f, value, 0.0f };
        dt_Lab_to_XYZ(lab, xyz);
        _XYZ_to_REC_709_normalized(xyz, pixel, 0.75f);
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_R:
      __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
      for(size_t j = 0; j < buffsize; j += 4)
      {
        const dt_aligned_pixel_t pixel = { in[j + 1], 0.0f, 0.0f, 0.0f };
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_G:
      __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
      for(size_t j = 0; j < buffsize; j += 4)
      {
        const dt_aligned_pixel_t pixel = { 0.0f, in[j + 1], 0.0f, 0.0f };
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_B:
      __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
      for(size_t j = 0; j < buffsize; j += 4)
      {
        const dt_aligned_pixel_t pixel = { 0.0f, 0.0f, in[j + 1], 0.0f };
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_LCH_C:
    case DT_DEV_PIXELPIPE_DISPLAY_HSL_S:
    case DT_DEV_PIXELPIPE_DISPLAY_JzCzhz_Cz:
      __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
      for(size_t j = 0; j < buffsize; j += 4)
      {
        const dt_aligned_pixel_t pixel = { 0.5f, 0.5f * (1.0f - in[j + 1]), 0.5f, 0.0f };
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_LCH_h:
      __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
      for(size_t j = 0; j < buffsize; j += 4)
      {
        dt_aligned_pixel_t lch = { 65.0f, 37.0f, in[j + 1], 0.0f };
        dt_aligned_pixel_t lab, xyz, pixel;
        dt_LCH_2_Lab(lch, lab);
        lab[3] = 0.0f;
        dt_Lab_to_XYZ(lab, xyz);
        _XYZ_to_REC_709_normalized(xyz, pixel, 0.75f);
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_HSL_H:
      __OMP_PARALLEL_FOR__()
      for(size_t j = 0; j < buffsize; j += 4)
      {
        dt_aligned_pixel_t hsl = { in[j + 1], 0.5f, 0.5f, 0.0f };
        dt_aligned_pixel_t pixel;
        dt_HSL_2_RGB(hsl, pixel);
        _normalize_color(pixel, 0.75f);
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_JzCzhz_hz:
      __OMP_PARALLEL_FOR__()
      for(size_t j = 0; j < buffsize; j += 4)
      {
        const dt_aligned_pixel_t JzCzhz = { 0.011f, 0.01f, in[j + 1] };
        dt_aligned_pixel_t JzAzBz;
        dt_aligned_pixel_t XYZ_D65;
        dt_aligned_pixel_t pixel;
        dt_JzCzhz_2_JzAzBz(JzCzhz, JzAzBz);
        dt_JzAzBz_2_XYZ(JzAzBz, XYZ_D65);
        dt_XYZ_to_Rec709_D65(XYZ_D65, pixel);
        _normalize_color(pixel, 0.75f);
        _write_pixel(pixel, out + j, preview, j / 4, in[j + 3] * alpha);
      }
      break;
    case DT_DEV_PIXELPIPE_DISPLAY_L:
    case DT_DEV_PIXELPIPE_DISPLAY_GRAY:
    case DT_DEV_PIXELPIPE_DISPLAY_HSL_l:
    case DT_DEV_PIXELPIPE_DISPLAY_JzCzhz_Jz:
    default:
      _channel_display_monochrome(in, out, buffsize, alpha, preview);
      break;
  }
}
__DT_CLONE_TARGETS__
static void _mask_display(const float *const restrict in, uint8_t *const restrict out, const size_t buffsize,
                          const float alpha, const dt_iop_gamma_mask_preview_t *const preview)
{
  // Loop over the displayed mask and preserve the image colors unless the global monochrome option is enabled.
  __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
  for(size_t j = 0; j < buffsize; j += 4)
  {
    dt_aligned_pixel_t pixel = { in[j], in[j + 1], in[j + 2], 0.0f };
    if(preview->black_and_white)
    {
      const float gray = 0.3f * in[j + 0] + 0.59f * in[j + 1] + 0.11f * in[j + 2];
      pixel[0] = pixel[1] = pixel[2] = gray;
    }
    const float hide = 1.0f - fminf(fmaxf(in[j + 3] * alpha, 0.0f), 1.0f);
    _write_pixel(pixel, out + j, preview, j / 4, hide);
  }
}
__DT_CLONE_TARGETS__
static void _copy_output(const float *const restrict in, uint8_t *const restrict out, const size_t buffsize)
{
  __OMP_PARALLEL_FOR_SIMD__(aligned(in, out: 64))
  for(size_t j = 0; j < buffsize; j += 4)
  {
    // the output of this module is BGR(A) instead of RGBA, so we can't use for_each_channel
    for(size_t c = 0; c < 3; c++)
    {
      out[j + 2 - c] = (uint8_t)(fminf(roundf(255.0f * fmaxf(in[j + c], 0.0f)), 255.0f));
    }
  }
}
 
 
int process(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, const void *const i, void *const o)
{
  const dt_iop_roi_t *const roi_out = &piece->roi_out;
  const dt_dev_pixelpipe_display_mask_t mask_display = pipe->mask_display;
  const size_t buffsize = (size_t)roi_out->width * roi_out->height * 4;
 
  if(!(mask_display & (DT_DEV_PIXELPIPE_DISPLAY_MASK | DT_DEV_PIXELPIPE_DISPLAY_CHANNEL)))
  {
    _copy_output((const float *const restrict)i, (uint8_t *const restrict)o, buffsize);
    return 0;
  }
 
  /* Settled in commit_params(); nothing here reads conf. A node whose allocation failed is
   * normally disabled by dt_iop_commit_params(), but this one is the last of the pipe and a
   * disabled display encoding is a black window -- so fall back to the plain copy, which is
   * what an ordinary frame does anyway, and lose only the preview. */
  const dt_iop_gamma_data_t *const d = (const dt_iop_gamma_data_t *)piece->data;
  if(IS_NULL_PTR(d))
  {
    _copy_output((const float *const restrict)i, (uint8_t *const restrict)o, buffsize);
    return 0;
  }
 
  const float alpha = (mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) ? 1.0f : 0.0f;
  dt_iop_gamma_mask_preview_t preview = d->preview;
  preview.width = roi_out->width;
 
  if((mask_display & DT_DEV_PIXELPIPE_DISPLAY_CHANNEL) && (mask_display & DT_DEV_PIXELPIPE_DISPLAY_ANY))
  {
    if(d->false_color)
    {
      _channel_display_false_color((const float *const restrict)i, (uint8_t *const restrict)o, buffsize, alpha,
                                   mask_display, &preview);
    }
    else
    {
      _channel_display_monochrome((const float *const restrict)i, (uint8_t *const restrict)o, buffsize, alpha,
                                  &preview);
    }
    return 0;
  }
 
  if(mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK)
  {
    _mask_display((const float *const restrict)i, (uint8_t *const restrict)o, buffsize, 1.0f, &preview);
    return 0;
  }
 
  _copy_output((const float *const restrict)i, (uint8_t *const restrict)o, buffsize);
  return 0;
}
 
#ifdef HAVE_OPENCL
static int _false_color_channel_to_kernel_code(const dt_dev_pixelpipe_display_mask_t mask_display)
{
  switch(mask_display & DT_DEV_PIXELPIPE_DISPLAY_ANY & ~DT_DEV_PIXELPIPE_DISPLAY_OUTPUT)
  {
    case DT_DEV_PIXELPIPE_DISPLAY_a:
      return DT_IOP_GAMMA_FALSE_COLOR_A;
    case DT_DEV_PIXELPIPE_DISPLAY_b:
      return DT_IOP_GAMMA_FALSE_COLOR_B;
    case DT_DEV_PIXELPIPE_DISPLAY_R:
      return DT_IOP_GAMMA_FALSE_COLOR_R;
    case DT_DEV_PIXELPIPE_DISPLAY_G:
      return DT_IOP_GAMMA_FALSE_COLOR_G;
    case DT_DEV_PIXELPIPE_DISPLAY_B:
      return DT_IOP_GAMMA_FALSE_COLOR_B_CH;
    case DT_DEV_PIXELPIPE_DISPLAY_LCH_C:
    case DT_DEV_PIXELPIPE_DISPLAY_HSL_S:
    case DT_DEV_PIXELPIPE_DISPLAY_JzCzhz_Cz:
      return DT_IOP_GAMMA_FALSE_COLOR_C;
    case DT_DEV_PIXELPIPE_DISPLAY_LCH_h:
      return DT_IOP_GAMMA_FALSE_COLOR_LCH_H;
    case DT_DEV_PIXELPIPE_DISPLAY_HSL_H:
      return DT_IOP_GAMMA_FALSE_COLOR_HSL_H;
    case DT_DEV_PIXELPIPE_DISPLAY_JzCzhz_hz:
      return DT_IOP_GAMMA_FALSE_COLOR_JZ_HZ;
    case DT_DEV_PIXELPIPE_DISPLAY_L:
    case DT_DEV_PIXELPIPE_DISPLAY_GRAY:
    case DT_DEV_PIXELPIPE_DISPLAY_HSL_l:
    case DT_DEV_PIXELPIPE_DISPLAY_JzCzhz_Jz:
    default:
      return DT_IOP_GAMMA_FALSE_COLOR_MONO;
  }
}
 
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_out = &piece->roi_out;
  dt_iop_gamma_global_data_t *gd = (dt_iop_gamma_global_data_t *)self->global_data;
  const int devid = pipe->devid;
  cl_int err = CL_SUCCESS;
 
  const int width = roi_out->width;
  const int height = roi_out->height;
 
  size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };
 
  const dt_dev_pixelpipe_display_mask_t mask_display = pipe->mask_display;
 
  /* Settled in commit_params(), exactly as the CPU path above reads it -- the two used to read
   * conf separately, which is how a GUI-only condition duplicated between process() and
   * process_cl() drifts (CLAUDE.md names this class by name). One source now, one commit. */
  const dt_iop_gamma_data_t *const d = (const dt_iop_gamma_data_t *)piece->data;
  if(IS_NULL_PTR(d)) return FALSE;
 
  int mode = DT_IOP_GAMMA_KERNEL_COPY;
  int channel = DT_IOP_GAMMA_FALSE_COLOR_MONO;
  float alpha = (mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) ? 1.0f : 0.0f;
  /* These two MUST stay arrays, not pointers to d->preview's. The kernel argument below is
   * sized with sizeof(), so a pointer passes 8 bytes of host address where the kernel wants a
   * 16-byte float4 -- CL_INVALID_KERNEL_ARGS (-52) on every frame, the GPU path failing over
   * to a CPU fallback that reads host input the RAM-caching policy never populated, i.e. the
   * previous life of a rekeyed cacheline: an older frame, drawn silently. Nothing warns,
   * because sizeof() on a pointer is perfectly legal. */
  dt_aligned_pixel_t checker_color_1;
  dt_aligned_pixel_t checker_color_2;
  for(int c = 0; c < 4; c++)
  {
    checker_color_1[c] = d->preview.checker_color_1[c];
    checker_color_2[c] = d->preview.checker_color_2[c];
  }
  const int checker_1 = (int)d->preview.checker_1;
  const int checker_2 = (int)d->preview.checker_2;
  const int black_and_white = d->preview.black_and_white ? 1 : 0;
 
  if((mask_display & DT_DEV_PIXELPIPE_DISPLAY_CHANNEL)
     && (mask_display & DT_DEV_PIXELPIPE_DISPLAY_ANY))
  {
    if(d->false_color)
    {
      mode = DT_IOP_GAMMA_KERNEL_CHANNEL_FALSE_COLOR;
      channel = _false_color_channel_to_kernel_code(mask_display);
    }
    else
    {
      mode = DT_IOP_GAMMA_KERNEL_CHANNEL_MONO;
    }
  }
  else if(mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK)
  {
    mode = DT_IOP_GAMMA_KERNEL_MASK;
    alpha = 1.0f;
  }
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 0, sizeof(cl_mem), (void *)&dev_in);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 1, sizeof(cl_mem), (void *)&dev_out);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 2, sizeof(int), (void *)&width);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 3, sizeof(int), (void *)&height);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 4, sizeof(int), (void *)&mode);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 5, sizeof(int), (void *)&channel);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 6, sizeof(float), (void *)&alpha);
  /* The kernel wants a float4 for each; sizeof() on a decayed pointer would quietly pass 8
   * bytes of host address instead, which the compiler cannot warn about. Checked here rather
   * than trusted, because the runtime symptom is an older frame drawn silently. */
  _Static_assert(sizeof(checker_color_1) == 4 * sizeof(float), "checker colour 1 must be a float4, not a pointer");
  _Static_assert(sizeof(checker_color_2) == 4 * sizeof(float), "checker colour 2 must be a float4, not a pointer");
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 7, sizeof(checker_color_1), (void *)&checker_color_1);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 8, sizeof(checker_color_2), (void *)&checker_color_2);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 9, sizeof(int), (void *)&checker_1);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 10, sizeof(int), (void *)&checker_2);
  dt_opencl_set_kernel_arg(devid, gd->kernel_gamma_pack, 11, sizeof(int), (void *)&black_and_white);
 
  err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_gamma_pack, sizes);
  if(err == CL_SUCCESS) return TRUE;
 
  dt_print(DT_DEBUG_OPENCL, "[opencl_gamma] couldn't enqueue kernel! %d\n", err);
  return FALSE;
}
 
void init_global(dt_iop_module_so_t *module)
{
  const int program = 2; // basic.cl, from programs.conf
  dt_iop_gamma_global_data_t *gd = (dt_iop_gamma_global_data_t *)calloc(1, sizeof(dt_iop_gamma_global_data_t));
  if(!gd) return;
  module->data = gd;
  gd->kernel_gamma_pack = dt_opencl_create_kernel(program, "gamma_pack");
}
 
void cleanup_global(dt_iop_module_so_t *module)
{
  dt_iop_gamma_global_data_t *gd = (dt_iop_gamma_global_data_t *)module->data;
  dt_opencl_free_kernel(gd->kernel_gamma_pack);
  dt_free(module->data);
}
#endif
 
void init(dt_iop_module_t *module)
{
  // module->data = malloc(sizeof(dt_iop_gamma_data_t));
  module->params = calloc(1, sizeof(dt_iop_gamma_params_t));
  module->default_params = calloc(1, sizeof(dt_iop_gamma_params_t));
  module->params_size = sizeof(dt_iop_gamma_params_t);
  module->hide_enable_button = 1;
  module->default_enabled = 1;
}
 
/* The settled mask-preview appearance is part of this node's effective contract, so it has to
 * be part of its cache key: the values come from conf, which no history carries, and without
 * this a changed checkerboard would be served from a cacheline keyed on the old one. The whole
 * struct is content -- no pointers -- so the full sizeof() is the hashed prefix. */
gboolean runtime_data_hash(struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe,
                           const dt_dev_pixelpipe_iop_t *piece)
{
  return TRUE;
}
 
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_gamma_data_t));
  piece->data_size = IS_NULL_PTR(piece->data) ? 0 : sizeof(dt_iop_gamma_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;
  piece->data_size = 0;
}
 
void commit_params(dt_iop_module_t *self, dt_iop_params_t *params, dt_dev_pixelpipe_t *pipe,
                   dt_dev_pixelpipe_iop_t *piece)
{
  // Only GUI pipes return 8 bits unsigned integer BGRA
  if(pipe->type == DT_DEV_PIXELPIPE_PREVIEW || pipe->type == DT_DEV_PIXELPIPE_FULL)
    piece->enabled = 1;
  else
    piece->enabled = 0;
 
  dt_iop_gamma_data_t *const d = (dt_iop_gamma_data_t *)piece->data;
  if(IS_NULL_PTR(d)) return;
 
  /* commit_params() runs for EVERY node of EVERY pipe, disabled ones included -- thumbnails,
   * exports, the navigation preview -- so anything read here is charged to all of them. This
   * module is enabled in the two GUI pipes only (just above), and the settled values below
   * describe a mask preview that cannot exist anywhere else.
   *
   * The cost is not the arithmetic: each dt_conf_get_* takes the application-wide
   * darktable.conf->mutex, and dt_conf_get_float additionally runs dt_calculator_solve() over
   * the stored string. Nine acquisitions of a lock the GUI thread holds constantly, per node
   * resync, on every thumbnail worker at once, is contention charged to the whole application
   * for a checkerboard no thumbnail can draw. */
  if(!piece->enabled) return;
 
  /* Settle the mask-preview appearance here, once, rather than in the two process() paths --
   * see dt_iop_gamma_data_t. The keys keep Color Balance's historical namespace because
   * views/darkroom.c's "Mask preview settings" toolbox writes them under those names, and it
   * is that toolbox (not this module) that owns them: its four writers bump
   * dev->mask_preview_settings_revision and call dt_dev_pixelpipe_resync_history_main(),
   * which re-runs commit_params() for EVERY node -- with default params where history has
   * none, which is this module's case, it carrying IOP_FLAGS_NO_HISTORY_STACK. */
  const float checker_1_rgb[3] = {
    CLAMP(dt_conf_get_float("plugins/darkroom/colorbalancergb/checker1/red"), 0.0f, 1.0f),
    CLAMP(dt_conf_get_float("plugins/darkroom/colorbalancergb/checker1/green"), 0.0f, 1.0f),
    CLAMP(dt_conf_get_float("plugins/darkroom/colorbalancergb/checker1/blue"), 0.0f, 1.0f)
  };
  const float checker_2_rgb[3] = {
    CLAMP(dt_conf_get_float("plugins/darkroom/colorbalancergb/checker2/red"), 0.0f, 1.0f),
    CLAMP(dt_conf_get_float("plugins/darkroom/colorbalancergb/checker2/green"), 0.0f, 1.0f),
    CLAMP(dt_conf_get_float("plugins/darkroom/colorbalancergb/checker2/blue"), 0.0f, 1.0f)
  };
 
  for(int c = 0; c < 3; c++)
  {
    d->preview.checker_color_1[c] = checker_1_rgb[c];
    d->preview.checker_color_2[c] = checker_2_rgb[c];
  }
  d->preview.checker_color_1[3] = 0.0f;
  d->preview.checker_color_2[3] = 0.0f;
 
  const size_t checker_size
      = MAX((size_t)DT_PIXEL_APPLY_DPI(dt_conf_get_int("plugins/darkroom/colorbalancergb/checker/size")), 2);
  d->preview.checker_1 = checker_size;
  d->preview.checker_2 = 2 * checker_size;
 
  // The ROI's, not a setting: filled by process(), and deliberately left 0 here so it cannot
  // reach the hash -- dt_pixelpipe_get_global_hash() already folds piece->roi_out in.
  d->preview.width = 0;
 
  d->preview.black_and_white
      = dt_conf_get_bool("plugins/darkroom/colorbalancergb/mask_preview/greyscaled");
  d->false_color = dt_conf_is_equal("channel_display", "false color");
}
 
// 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