pixelpipe_gui.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2009-2022 darktable developers.
    Copyright (C) 2026 Aurélien PIERRE.
    
    Ansel 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.
    
    Ansel 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 Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "common/color_picker.h"
#include "common/darktable.h"
#include "common/histogram.h"
#include "common/iop_order.h"
#include "control/signal.h"
#include "develop/blend.h"
#include "develop/pixelpipe.h"
#include "develop/pixelpipe_cache.h"
#include "gui/color_picker_proxy.h"
#include "libs/colorpicker.h"
 
#include <math.h>
#include <string.h>
 
typedef enum dt_pixelpipe_picker_source_t
{
  PIXELPIPE_PICKER_INPUT = 0,
  PIXELPIPE_PICKER_OUTPUT = 1
} dt_pixelpipe_picker_source_t;
 
static void histogram_collect(dt_dev_pixelpipe_iop_t *piece, const void *pixel, const dt_iop_roi_t roi,
                              uint32_t **histogram, uint32_t *histogram_max)
{
  dt_dev_histogram_collection_params_t histogram_params = piece->histogram_params;
  dt_histogram_roi_t histogram_roi;
 
  // If the current module did not specify its own ROI, use the full ROI.
  if(histogram_params.roi == NULL)
  {
    histogram_roi = (dt_histogram_roi_t){
      .width = roi.width, .height = roi.height, .crop_x = 0, .crop_y = 0, .crop_width = 0, .crop_height = 0
    };
 
    histogram_params.roi = &histogram_roi;
  }
 
  const dt_iop_colorspace_type_t cst = piece->module->input_colorspace(piece->module, piece->pipe, piece);
 
  dt_histogram_helper(&histogram_params, &piece->histogram_stats, cst, piece->module->histogram_cst, pixel, histogram,
                      piece->module->histogram_middle_grey, dt_ioppr_get_pipe_work_profile_info(piece->pipe));
  dt_histogram_max_helper(&piece->histogram_stats, cst, piece->module->histogram_cst, histogram, histogram_max);
}
 
static dt_backbuf_t *_get_backuf(dt_develop_t *dev, const char *op)
{
  if(!strcmp(op, "demosaic"))
    return &dev->raw_histogram;
  else if(!strcmp(op, "colorout"))
    return &dev->output_histogram;
  else if(!strcmp(op, "gamma"))
    return &dev->display_histogram;
  else
    return NULL;
}
 
static void pixelpipe_get_histogram_backbuf(dt_develop_t *dev, const dt_iop_roi_t roi, dt_pixel_cache_entry_t *entry,
                                            dt_iop_module_t *module, const uint64_t hash);
 
static inline gboolean _pipe_tracks_gui_observables(const dt_dev_pixelpipe_t *pipe, const dt_develop_t *dev)
{
  return pipe && dev && dev->gui_attached && pipe->gui_observable_source;
}
 
static inline gboolean _module_requests_color_picker(const dt_develop_t *dev, const dt_iop_module_t *module)
{
  return dev && module && dev->gui_module && darktable.lib->proxy.colorpicker.picker_proxy
         && module == dev->gui_module && dev->gui_module->enabled
         && dev->gui_module->request_color_pick != DT_REQUEST_COLORPICK_OFF;
}
 
static inline gboolean _module_requests_input_histogram(const dt_develop_t *dev,
                                                        const dt_dev_pixelpipe_iop_t *piece)
{
  return dev && piece && (piece->request_histogram & DT_REQUEST_ON)
         && (dev->gui_attached || !(piece->request_histogram & DT_REQUEST_ONLY_IN_GUI));
}
 
static inline gboolean _module_needs_gui_host_input_sampling(const dt_dev_pixelpipe_t *pipe,
                                                             const dt_develop_t *dev,
                                                             const dt_iop_module_t *module,
                                                             const dt_dev_pixelpipe_iop_t *piece)
{
  return _pipe_tracks_gui_observables(pipe, dev)
         && (_module_requests_color_picker(dev, module)
             || _module_requests_input_histogram(dev, piece));
}
 
static inline gboolean _module_needs_gui_output_backbuf_sync(const dt_dev_pixelpipe_t *pipe,
                                                             const dt_develop_t *dev,
                                                             const dt_iop_module_t *module)
{
  return _pipe_tracks_gui_observables(pipe, dev) && !dt_dev_pixelpipe_get_realtime(pipe)
         && module && _get_backuf((dt_develop_t *)dev, module->op) && strcmp(module->op, "gamma") != 0;
}
 
static inline gboolean _module_needs_gui_input_backbuf_sync(const dt_dev_pixelpipe_t *pipe,
                                                            const dt_develop_t *dev,
                                                            const dt_iop_module_t *module)
{
  return _pipe_tracks_gui_observables(pipe, dev) && !dt_dev_pixelpipe_get_realtime(pipe)
         && module && !strcmp(module->op, "gamma");
}
 
static gboolean _pipe_needs_gui_sampling_traversal(const dt_dev_pixelpipe_t *pipe, const dt_develop_t *dev)
{
  if(!_pipe_tracks_gui_observables(pipe, dev) || !pipe->nodes) return FALSE;
 
  for(GList *pieces = g_list_first(pipe->nodes); pieces; pieces = g_list_next(pieces))
  {
    dt_dev_pixelpipe_iop_t *piece = (dt_dev_pixelpipe_iop_t *)pieces->data;
    if(piece && piece->enabled
       && _module_needs_gui_host_input_sampling(pipe, dev, piece->module, piece))
      return TRUE;
  }
 
  return FALSE;
}
 
static inline gboolean _module_exact_hit_must_recurse_for_picker(const dt_dev_pixelpipe_t *pipe,
                                                                 const dt_develop_t *dev,
                                                                 const dt_iop_module_t *module)
{
  return _pipe_tracks_gui_observables(pipe, dev)
         && module
         && dev
         && dev->gui_module
         && darktable.lib->proxy.colorpicker.picker_proxy
         && dev->gui_module->enabled
         && dev->gui_module->request_color_pick != DT_REQUEST_COLORPICK_OFF
         && module != dev->gui_module
         && module->iop_order > dev->gui_module->iop_order;
}
 
static void _sync_module_output_backbuf_on_exact_hit(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev,
                                                     dt_iop_module_t *module, dt_dev_pixelpipe_iop_t *piece,
                                                     dt_pixel_cache_entry_t *output_entry,
                                                     const dt_iop_roi_t roi_out, const uint64_t hash)
{
  if(!_module_needs_gui_output_backbuf_sync(pipe, dev, module) || !output_entry) return;
  pixelpipe_get_histogram_backbuf(dev, roi_out, output_entry, piece->module, hash);
}
 
static void pixelpipe_get_histogram_backbuf(dt_develop_t *dev, const dt_iop_roi_t roi, dt_pixel_cache_entry_t *entry,
                                            dt_iop_module_t *module, const uint64_t hash)
{
  dt_backbuf_t *backbuf = _get_backuf(dev, module->op);
  if(backbuf == NULL) return;     // This module is not wired to global histograms.
  if(dt_dev_backbuf_get_hash(backbuf) == hash) return; // Hash didn't change, nothing to update.
 
  // Hash has changed, our previous stored entry is obsolete: decrement its refcount.
  dt_pixel_cache_entry_t *previous_entry;
  if(dt_dev_pixelpipe_cache_peek(darktable.pixelpipe_cache, dt_dev_backbuf_get_hash(backbuf), NULL, NULL,
                                 &previous_entry))
    dt_dev_pixelpipe_cache_ref_count_entry(darktable.pixelpipe_cache, DT_PIXELPIPE_CACHE_HASH_INVALID, FALSE, previous_entry);
 
  // Update metadata. The global histogram backbuf stores its bpp; infer it from cache entry size.
  const size_t entry_size = dt_pixel_cache_entry_get_size(entry);
  const int bpp = (roi.width > 0 && roi.height > 0) ? (int)(entry_size / ((size_t)roi.width * (size_t)roi.height)) : 0;
  dt_dev_set_backbuf(backbuf, roi.width, roi.height, bpp, hash, -1);
 
  // Increment the refcount on current entry so nobody removes it while the GUI still needs it.
  dt_dev_pixelpipe_cache_ref_count_entry(darktable.pixelpipe_cache, DT_PIXELPIPE_CACHE_HASH_INVALID, TRUE, entry);
}
 
static int pixelpipe_picker_helper(dt_iop_module_t *module, const dt_iop_roi_t roi, dt_aligned_pixel_t picked_color,
                                   dt_aligned_pixel_t picked_color_min, dt_aligned_pixel_t picked_color_max,
                                   dt_pixelpipe_picker_source_t picker_source, int *box)
{
  const int width = roi.width;
  const int height = roi.height;
  const dt_colorpicker_sample_t *const sample = darktable.lib->proxy.colorpicker.primary_sample;
 
  dt_boundingbox_t fbox = { 0.0f };
 
  // Get absolute pixel coordinates in final preview image.
  if(sample->size == DT_LIB_COLORPICKER_SIZE_BOX)
  {
    memcpy(fbox, sample->box, sizeof(float) * 4);
    dt_dev_coordinates_image_norm_to_preview_abs(darktable.develop, fbox, 2);
  }
  else if(sample->size == DT_LIB_COLORPICKER_SIZE_POINT)
  {
    fbox[0] = sample->point[0];
    fbox[1] = sample->point[1];
    dt_dev_coordinates_image_norm_to_preview_abs(darktable.develop, fbox, 1);
    fbox[2] = fbox[0];
    fbox[3] = fbox[1];
  }
 
  // Transform back to current module coordinates.
  dt_dev_distort_backtransform_plus(darktable.develop, darktable.develop->preview_pipe, module->iop_order,
                                    (picker_source == PIXELPIPE_PICKER_INPUT) ? DT_DEV_TRANSFORM_DIR_FORW_INCL
                                                                              : DT_DEV_TRANSFORM_DIR_FORW_EXCL,
                                    fbox, 2);
 
  fbox[0] -= roi.x;
  fbox[1] -= roi.y;
  fbox[2] -= roi.x;
  fbox[3] -= roi.y;
 
  // Re-order edges of bounding box.
  box[0] = fminf(fbox[0], fbox[2]);
  box[1] = fminf(fbox[1], fbox[3]);
  box[2] = fmaxf(fbox[0], fbox[2]);
  box[3] = fmaxf(fbox[1], fbox[3]);
 
  if(sample->size == DT_LIB_COLORPICKER_SIZE_POINT)
  {
    // If we are sampling one point, make sure that we actually sample it.
    for(int k = 2; k < 4; k++) box[k] += 1;
  }
 
  // Do not continue if box is completely outside of roi.
  if(box[0] >= width || box[1] >= height || box[2] < 0 || box[3] < 0) return 1;
 
  // Clamp bounding box to roi.
  for(int k = 0; k < 4; k += 2) box[k] = MIN(width - 1, MAX(0, box[k]));
  for(int k = 1; k < 4; k += 2) box[k] = MIN(height - 1, MAX(0, box[k]));
 
  // Safety check: area needs to have minimum 1 pixel width and height.
  if(box[2] <= box[0] || box[3] <= box[1]) return 1;
 
  // If module isn't the one where pickers are assigned, reset the values and don't sample.
  if(module != darktable.develop->gui_module)
  {
    for(int k = 0; k < 4; k++)
    {
      picked_color_min[k] = INFINITY;
      picked_color_max[k] = -INFINITY;
      picked_color[k] = 0.0f;
    }
    return 1;
  }
 
  return 0;
}
 
static void pixelpipe_picker(dt_iop_module_t *module, dt_dev_pixelpipe_iop_t *piece, dt_iop_buffer_dsc_t *dsc,
                             const float *pixel, const dt_iop_roi_t roi, float *picked_color,
                             float *picked_color_min, float *picked_color_max,
                             const dt_iop_colorspace_type_t image_cst, dt_pixelpipe_picker_source_t picker_source)
{
  int box[4];
  if(pixelpipe_picker_helper(module, roi, picked_color, picked_color_min, picked_color_max, picker_source, box))
    return;
 
  dt_aligned_pixel_t avg = { 0.0f };
  dt_aligned_pixel_t min = { 0.0f };
  dt_aligned_pixel_t max = { 0.0f };
 
  const dt_iop_order_iccprofile_info_t *const profile = dt_ioppr_get_pipe_work_profile_info(piece->pipe);
 
  dt_color_picker_helper(dsc, pixel, &roi, box, avg, min, max, image_cst,
                         dt_iop_color_picker_get_active_cst(module), profile);
 
  for(int k = 0; k < 4; k++)
  {
    picked_color_min[k] = min[k];
    picked_color_max[k] = max[k];
    picked_color[k] = avg[k];
  }
}
 
static dt_iop_colorspace_type_t _transform_for_picker(dt_iop_module_t *self, const dt_iop_colorspace_type_t cst)
{
  const dt_iop_colorspace_type_t picker_cst = dt_iop_color_picker_get_active_cst(self);
 
  switch(picker_cst)
  {
    case IOP_CS_LAB:
    case IOP_CS_RGB:
    case IOP_CS_HSL:
    case IOP_CS_JZCZHZ:
      return IOP_CS_RGB;
    case IOP_CS_NONE:
      // IOP_CS_NONE is used by temperature.c as it may work in RAW or RGB: return the pipe colorspace to avoid
      // extra conversions.
      return cst;
    default:
      return picker_cst;
  }
}
 
static void collect_histogram_on_CPU(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev,
                                     float *input, const dt_iop_roi_t roi_in,
                                     dt_iop_buffer_dsc_t *input_format,
                                     dt_iop_module_t *module, dt_dev_pixelpipe_iop_t *piece)
{
  // Histogram collection for module.
  if((dev->gui_attached || !(piece->request_histogram & DT_REQUEST_ONLY_IN_GUI))
     && (piece->request_histogram & DT_REQUEST_ON))
  {
    const dt_iop_order_iccprofile_info_t *const work_profile
        = (input_format->cst != IOP_CS_RAW) ? dt_ioppr_get_pipe_work_profile_info(pipe) : NULL;
 
    // Transform to module input colorspace.
    dt_ioppr_transform_image_colorspace(module, input, input, roi_in.width, roi_in.height, input_format->cst,
                                        module->input_colorspace(module, pipe, piece), &input_format->cst,
                                        work_profile);
 
    histogram_collect(piece, input, roi_in, &(piece->histogram), piece->histogram_max);
 
    if(piece->histogram && (module->request_histogram & DT_REQUEST_ON))
    {
      const size_t buf_size = 4 * piece->histogram_stats.bins_count * sizeof(uint32_t);
      module->histogram = realloc(module->histogram, buf_size);
      memcpy(module->histogram, piece->histogram, buf_size);
      module->histogram_stats = piece->histogram_stats;
      memcpy(module->histogram_max, piece->histogram_max, sizeof(piece->histogram_max));
      if(module->widget) dt_control_queue_redraw_widget(module->widget);
    }
  }
}
 
static void _sample_color_picker(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev, float *input,
                                 dt_iop_buffer_dsc_t *input_format, const dt_iop_roi_t roi_in, void **output,
                                 dt_iop_buffer_dsc_t **out_format, const dt_iop_roi_t roi_out,
                                 dt_iop_module_t *module, dt_dev_pixelpipe_iop_t *piece)
{
  if(!(darktable.lib->proxy.colorpicker.picker_proxy
       && module == dev->gui_module
       && dev->gui_module->enabled
       && module->request_color_pick != DT_REQUEST_COLORPICK_OFF))
    return;
 
  const dt_iop_order_iccprofile_info_t *const work_profile
      = (input_format->cst != IOP_CS_RAW) ? dt_ioppr_get_pipe_work_profile_info(pipe) : NULL;
 
  // Ensure we are using the right colorspace for picker values.
  dt_iop_colorspace_type_t picker_cst = _transform_for_picker(module, pipe->dsc.cst);
  dt_ioppr_transform_image_colorspace(module, input, input, roi_in.width, roi_in.height,
                                      input_format->cst, picker_cst, &input_format->cst,
                                      work_profile);
  dt_ioppr_transform_image_colorspace(module, *output, *output, roi_out.width, roi_out.height,
                                      pipe->dsc.cst, picker_cst, &pipe->dsc.cst,
                                      work_profile);
 
  pixelpipe_picker(module, piece, &piece->dsc_in, (float *)input, roi_in, module->picked_color,
                   module->picked_color_min, module->picked_color_max, input_format->cst, PIXELPIPE_PICKER_INPUT);
  pixelpipe_picker(module, piece, &pipe->dsc, (float *)(*output), roi_out, module->picked_output_color,
                   module->picked_output_color_min, module->picked_output_color_max,
                   pipe->dsc.cst, PIXELPIPE_PICKER_OUTPUT);
 
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_CONTROL_PICKERDATA_READY, module, piece);
}
 
static void _sample_gui(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev, void *input, void **output,
                        const dt_iop_roi_t roi_in, const dt_iop_roi_t roi_out, dt_iop_buffer_dsc_t *input_format,
                        dt_iop_buffer_dsc_t **output_format, dt_iop_module_t *module, dt_dev_pixelpipe_iop_t *piece,
                        const uint64_t input_hash, const uint64_t hash, const size_t in_bpp, const size_t bpp,
                        dt_pixel_cache_entry_t *const input_entry, dt_pixel_cache_entry_t *const output_entry)
{
  (void)in_bpp;
  (void)bpp;
 
  if(!_pipe_tracks_gui_observables(pipe, dev))
    return;
 
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, DT_PIXELPIPE_CACHE_HASH_INVALID, TRUE, output_entry);
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, DT_PIXELPIPE_CACHE_HASH_INVALID, TRUE, input_entry);
 
  // Need to go first because we want module output RGB without color conversion.
  // Gamma outputs uint8_t so we take its input. We want float32.
  dt_iop_roi_t roi;
  dt_pixel_cache_entry_t *entry;
  int64_t buf_hash;
 
  if(strcmp(module->op, "gamma") == 0)
  {
    roi = roi_in;
    entry = input_entry;
    buf_hash = input_hash;
  }
  else
  {
    roi = roi_out;
    entry = output_entry;
    buf_hash = hash;
  }
 
  // Copy the cache entry reference to global histogram cache, except in
  // realtime mode where we intentionally skip global histogram sampling.
  if(!dt_dev_pixelpipe_get_realtime(pipe))
    pixelpipe_get_histogram_backbuf(dev, roi, entry, piece->module, buf_hash);
 
  // Sample internal histogram on input and color pickers.
  collect_histogram_on_CPU(pipe, dev, (float *)input, roi_in, input_format, module, piece);
  _sample_color_picker(pipe, dev, (float *)input, input_format, roi_in, output, output_format, roi_out, module, piece);
 
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, DT_PIXELPIPE_CACHE_HASH_INVALID, FALSE, output_entry);
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, DT_PIXELPIPE_CACHE_HASH_INVALID, FALSE, input_entry);
}
 
static gboolean _resync_global_histograms(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev)
{
  if(dt_dev_pixelpipe_get_realtime(pipe)) return 1;
  if(!_pipe_tracks_gui_observables(pipe, dev)) return 1;
 
  GList *pieces = g_list_first(pipe->nodes);
  int64_t input_hash = -1;
 
  while(pieces)
  {
    dt_dev_pixelpipe_iop_t *piece = (dt_dev_pixelpipe_iop_t *)pieces->data;
    if(piece->enabled)
    {
      int64_t hash = piece->global_hash;
 
      if(_get_backuf(dev, piece->module->op))
      {
        // Gamma outputs uint8_t so we take its input. We want float32.
        dt_iop_roi_t roi;
        dt_pixel_cache_entry_t *entry;
        int64_t buf_hash;
 
        if(strcmp(piece->module->op, "gamma") == 0)
        {
          roi = piece->planned_roi_in;
          buf_hash = input_hash;
        }
        else
        {
          roi = piece->planned_roi_out;
          buf_hash = hash;
        }
 
        if(!dt_dev_pixelpipe_cache_peek(darktable.pixelpipe_cache, buf_hash, NULL, NULL, &entry))
          return 0;
 
        pixelpipe_get_histogram_backbuf(dev, roi, entry, piece->module, buf_hash);
      }
 
      input_hash = hash;
    }
 
    pieces = g_list_next(pieces);
  }
 
  return 1;
}
 
// 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