develop.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2015, 2018 johannes hanika.
    Copyright (C) 2010 Alexandre Prokoudine.
    Copyright (C) 2010-2011 Bruce Guenter.
    Copyright (C) 2010-2012 Henrik Andersson.
    Copyright (C) 2011 Karl Mikaelsson.
    Copyright (C) 2011 Mikko Ruohola.
    Copyright (C) 2011 Omari Stephens.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2011 Rostyslav Pidgornyi.
    Copyright (C) 2011-2019 Tobias Ellinghaus.
    Copyright (C) 2012-2014, 2016, 2020-2021 Aldric Renaudin.
    Copyright (C) 2012 Antony Dovgal.
    Copyright (C) 2012 Moritz Lipp.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2014, 2016-2017 Ulrich Pegelow.
    Copyright (C) 2013-2022 Pascal Obry.
    Copyright (C) 2014, 2020 Dan Torop.
    Copyright (C) 2014 parafin.
    Copyright (C) 2014-2015 Pedro Côrte-Real.
    Copyright (C) 2014-2017 Roman Lebedev.
    Copyright (C) 2016 Alexander V. Smal.
    Copyright (C) 2017, 2021 luzpaz.
    Copyright (C) 2018-2019 Edgardo Hoszowski.
    Copyright (C) 2019 Alexander Blinne.
    Copyright (C) 2019-2020, 2022-2026 Aurélien PIERRE.
    Copyright (C) 2019-2021 Diederik Ter Rahe.
    Copyright (C) 2019-2022 Hanno Schwalm.
    Copyright (C) 2019 Heiko Bauke.
    Copyright (C) 2019-2020 Philippe Weyland.
    Copyright (C) 2020-2021 Chris Elston.
    Copyright (C) 2020 GrahamByrnes.
    Copyright (C) 2020 Harold le Clément de Saint-Marcq.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2020 JP Verrue.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2021 paolodepetrillo.
    Copyright (C) 2021 Sakari Kapanen.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023 Alynx Zhou.
    Copyright (C) 2023 lologor.
    Copyright (C) 2023 Luca Zulberti.
    Copyright (C) 2023 Ricky Moon.
    Copyright (C) 2025-2026 Guillaume Stutin.
    
    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/>.
*/
#include <assert.h>
#include <stddef.h>
#include <glib/gprintf.h>
#include <inttypes.h>
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
 
#include "develop/imageop_gui.h"
#include "widgets/widget_settings.h"
#include "system/atomic.h"
#include "history/history.h"
#include "caches/image_cache.h"
#include "caches/mipmap_cache.h"
#include "metadata/tags.h"
#include "common/conf.h"
#include "common/image.h"
#include "common/paths.h"   // DT_PATH_MAX
#include "control/control.h"
#include "control/signal.h"
#include "control/jobs.h"
#include "control/user_message.h"
#include "develop/blend.h"
#include "develop/develop.h"
#include "develop/imageop.h"
#include "develop/lightroom.h"
#include "develop/masks.h"
#include "caches/pixelpipe_cache.h"
#include "gui/application.h"
#include "develop/geometry/geometry.h"
#include "develop/gui_throttle.h"
#include "libs/colorpicker.h"
#include "widgets/label.h"
#include "widgets/widget_style.h"
#include "gui/screen_metrics.h"
 
#define DT_IOP_ORDER_INFO (dt_get_debug_flags() & DT_DEBUG_IOPORDER)
 
GList *dt_dev_load_modules(dt_develop_t *dev)
{
  GList *res = NULL;
  dt_iop_module_t *module;
  dt_iop_module_so_t *module_so;
  GList *iop = g_list_first(dt_iop_get_modules_so());
  while(iop)
  {
    module_so = (dt_iop_module_so_t *)iop->data;
    module = (dt_iop_module_t *)calloc(1, sizeof(dt_iop_module_t));
    if(dt_iop_load_module_by_so(module, module_so, dev))
    {
      dt_free(module);
      continue;
    }
    res = g_list_insert_sorted(res, module, dt_sort_iop_by_order);
    module->global_data = module_so->data;
    module->so = module_so;
    iop = g_list_next(iop);
  }
 
  /* Give every base module a distinct `instance`.
   *
   * `instance` identifies a module FAMILY: a base module and every extra instance
   * duplicated from it share one value, and dt_dev_module_duplicate() scans dev->iop for
   * `mod->instance == base->instance` to find the next free multi_priority and multi_name.
   * With every module left at the calloc'd 0, that scan matches every module of every
   * operation, so duplicating `retouch` picked up the numbering of an unrelated `exposure`
   * copy and produced retouch "2" with no "1" -- issue #1265.
   *
   * Runtime-only: the database and XMP store multi_priority and multi_name, never this, so
   * the numbering does not have to be stable across sessions -- only distinct within a dev.
   *
   * 214cc1cc8e removed this line while tidying dt_develop_t and left the loop empty; the
   * counter it uses stayed on the struct, unread, which is why nothing complained. */
  GList *it = res;
  while(it)
  {
    module = (dt_iop_module_t *)it->data;
    module->instance = dev->iop_instance++;
    it = g_list_next(it);
  }
  return res;
}
 
void dt_dev_init(dt_develop_t *dev, int32_t gui_attached)
{
  memset(dev, 0, sizeof(dt_develop_t));
  dt_dev_geometry_init(dev);
  dt_dev_roi_request_init(dev);
  dt_dev_set_history_hash(dev, DT_PIXELPIPE_CACHE_HASH_INVALID);
  dt_pthread_rwlock_init(&dev->history_mutex, NULL);
  dt_pthread_rwlock_set_name(&dev->history_mutex, "history_mutex"); // find_history_mutex_blocker, temporary
  dt_pthread_rwlock_init(&dev->masks_mutex, NULL);
  dt_pthread_mutex_init(&dev->transient_params_mutex, NULL);
 
  dev->gui_attached = gui_attached;
  if(gui_attached) dev->viewport = dt_dev_viewport_new();
 
  dt_image_init(&dev->image_storage);
 
  if(dev->gui_attached)
  {
    dev->pipe = (dt_dev_pixelpipe_t *)malloc(sizeof(dt_dev_pixelpipe_t));
    dev->preview_pipe = (dt_dev_pixelpipe_t *)malloc(sizeof(dt_dev_pixelpipe_t));
    dt_dev_pixelpipe_init(dev->pipe, dev);
    dt_dev_pixelpipe_init_preview(dev->preview_pipe, dev);
 
    /* Where the GUI gets sizes and coordinates from (doc/geometry-service.md). GUI devs only:
     * it answers GUI questions and is GUI-thread state, so a headless dev has nothing to do with
     * one -- which is also what makes the NULL chain the guard on every entry point. */
    dev->geometry_chain = dt_geometry_chain_new();
  }
 
  dt_dev_set_backbuf(&dev->raw_histogram, 0, 0, 0, -1, -1);
  dt_dev_set_backbuf(&dev->output_histogram, 0, 0, 0, -1, -1);
  dt_dev_set_backbuf(&dev->display_histogram, 0, 0, 0, -1, -1);
 
  dev->proxy.wb_is_D65 = TRUE; // don't display error messages until we know for sure it's FALSE
  dev->proxy.wb_coeffs[0] = 0.f;
 
  // Overlay toolbar prefs have been found corrupted on disk (heap-looking int garbage, zeroed
  // floats). An out-of-enum mode/colorscheme indexes the fixed-size color tables of
  // iop/rawoverexposed.c out of bounds and selects diverging CPU/OpenCL preview paths (the CL
  // switch defaults to false color), painting the whole image as a CFA checkerboard. An invalid
  // enum means the whole stored group is untrustworthy: restore the group defaults instead of
  // clamping, so a corrupted threshold does not survive as a legal-looking value.
  const int raw_mode = dt_conf_get_int("darkroom/ui/rawoverexposed/mode");
  const int raw_colorscheme = dt_conf_get_int("darkroom/ui/rawoverexposed/colorscheme");
  const float raw_threshold = dt_conf_get_float("darkroom/ui/rawoverexposed/threshold");
  if(raw_mode >= DT_DEV_RAWOVEREXPOSED_MODE_MARK_CFA && raw_mode <= DT_DEV_RAWOVEREXPOSED_MODE_FALSECOLOR
     && raw_colorscheme >= DT_DEV_RAWOVEREXPOSED_RED && raw_colorscheme <= DT_DEV_RAWOVEREXPOSED_BLACK
     && raw_threshold >= 0.f && raw_threshold <= 2.f)
  {
    dev->rawoverexposed.mode = raw_mode;
    dev->rawoverexposed.colorscheme = raw_colorscheme;
    dev->rawoverexposed.threshold = raw_threshold;
  }
  else
  {
    dev->rawoverexposed.mode = DT_DEV_RAWOVEREXPOSED_MODE_MARK_CFA;
    dev->rawoverexposed.colorscheme = DT_DEV_RAWOVEREXPOSED_RED;
    dev->rawoverexposed.threshold = 1.f;
  }
 
  const int over_mode = dt_conf_get_int("darkroom/ui/overexposed/mode");
  const int over_colorscheme = dt_conf_get_int("darkroom/ui/overexposed/colorscheme");
  const float over_lower = dt_conf_get_float("darkroom/ui/overexposed/lower");
  const float over_upper = dt_conf_get_float("darkroom/ui/overexposed/upper");
  if(over_mode >= DT_CLIPPING_PREVIEW_GAMUT && over_mode <= DT_CLIPPING_PREVIEW_SATURATION
     && over_colorscheme >= DT_DEV_OVEREXPOSED_BLACKWHITE && over_colorscheme <= DT_DEV_OVEREXPOSED_PURPLEGREEN
     && over_lower >= -32.f && over_lower <= -4.f && over_upper >= 0.f && over_upper <= 100.f)
  {
    dev->overexposed.mode = over_mode;
    dev->overexposed.colorscheme = over_colorscheme;
    dev->overexposed.lower = over_lower;
    dev->overexposed.upper = over_upper;
  }
  else
  {
    dev->overexposed.mode = DT_CLIPPING_PREVIEW_GAMUT;
    dev->overexposed.colorscheme = DT_DEV_OVEREXPOSED_REDBLUE;
    dev->overexposed.lower = -12.69f;
    dev->overexposed.upper = 99.99f;
  }
 
  if(dev->gui_attached)
  {
    dev->color_picker.primary_sample = g_malloc0(sizeof(dt_colorpicker_sample_t));
    dev->color_picker.display_samples = dt_conf_get_bool("ui_last/colorpicker_display_samples");
    dev->color_picker.live_samples_enabled = TRUE;
    dev->color_picker.restrict_histogram = dt_conf_get_bool("ui_last/colorpicker_restrict_histogram");
  }
 
  dt_dev_reset_roi(dev);
 
  dev->iop = dt_dev_load_modules(dev);
}
 
void dt_dev_cleanup(dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev)) return;
  // image_cache does not have to be unref'd, this is done outside develop module.
 
  dt_gui_throttle_cancel(dev);
  dt_dev_history_drop_pending_commits(dev);
 
  dt_dev_viewport_free(dev->viewport);
  dev->viewport = NULL;
 
  dev->proxy.chroma_adaptation = NULL;
  dev->proxy.wb_coeffs[0] = 0.f;
  if(dev->pipe)
  {
    dt_dev_pixelpipe_cleanup(dev->pipe);
    dt_free(dev->pipe);
  }
  if(dev->preview_pipe)
  {
    dt_dev_pixelpipe_cleanup(dev->preview_pipe);
    dt_free(dev->preview_pipe);
  }
  dt_geometry_chain_free(dev->geometry_chain);
  dev->geometry_chain = NULL;
 
  dt_pthread_rwlock_wrlock(&dev->history_mutex);
  while(dev->history)
  {
    dt_dev_free_history_item(((dt_dev_history_item_t *)dev->history->data));
    dev->history = g_list_delete_link(dev->history, dev->history);
  }
  dt_pthread_rwlock_unlock(&dev->history_mutex);
  dt_pthread_rwlock_destroy(&dev->history_mutex);
 
  // free pending "before" snapshots for history undo
  dev->undo_history_depth = 0;
  g_list_free_full(dev->undo_history_before_snapshot, dt_dev_free_history_item);
  dev->undo_history_before_snapshot = NULL;
  g_list_free_full(dev->undo_history_before_iop_order_list, dt_free_gpointer);
  dev->undo_history_before_iop_order_list = NULL;
  dev->undo_history_before_end = 0;
 
  // free the transient param channel
  dt_pthread_mutex_lock(&dev->transient_params_mutex);
  dt_free(dev->transient_params.params);
  dev->transient_params.params = NULL;
  dt_free(dev->transient_params.blend_params);
  dev->transient_params.blend_params = NULL;
  dev->transient_params.module = NULL;
  dt_pthread_mutex_unlock(&dev->transient_params_mutex);
  dt_pthread_mutex_destroy(&dev->transient_params_mutex);
 
  while(dev->iop)
  {
    dt_iop_cleanup_module((dt_iop_module_t *)dev->iop->data);
    dt_free(dev->iop->data);
    dev->iop = g_list_delete_link(dev->iop, dev->iop);
  }
  while(dev->alliop)
  {
    dt_iop_cleanup_module((dt_iop_module_t *)dev->alliop->data);
    dt_free(dev->alliop->data);
    dev->alliop = g_list_delete_link(dev->alliop, dev->alliop);
  }
  g_list_free_full(dev->iop_order_list, dt_free_gpointer);
  dev->iop_order_list = NULL;
 
  if(dev->color_picker.primary_sample)
  {
    dt_free(dev->color_picker.primary_sample);
    dev->color_picker.primary_sample = NULL;
  }
 
  dt_masks_release_all_forms(dev);
 
  dt_pthread_rwlock_destroy(&dev->masks_mutex);
 
  // Overlay toolbar prefs may only be persisted by a gui_attached develop: transient devs
  // (export, styles, snapshots, history copies) never expose the toolbar, run on worker
  // threads, and would keep re-writing these keys on every background job — one corrupted
  // or racing write is then resurrected as the user's settings at every later startup.
  if(dev->gui_attached)
  {
    dt_conf_set_int("darkroom/ui/rawoverexposed/mode", dev->rawoverexposed.mode);
    dt_conf_set_int("darkroom/ui/rawoverexposed/colorscheme", dev->rawoverexposed.colorscheme);
    dt_conf_set_float("darkroom/ui/rawoverexposed/threshold", dev->rawoverexposed.threshold);
 
    dt_conf_set_int("darkroom/ui/overexposed/mode", dev->overexposed.mode);
    dt_conf_set_int("darkroom/ui/overexposed/colorscheme", dev->overexposed.colorscheme);
    dt_conf_set_float("darkroom/ui/overexposed/lower", dev->overexposed.lower);
    dt_conf_set_float("darkroom/ui/overexposed/upper", dev->overexposed.upper);
  }
}
 
static gboolean _update_darkroom_roi(dt_develop_t *dev, dt_dev_pixelpipe_t *pipe, int *x, int *y, int *wd, int *ht,
                                     float *scale);
 
static gboolean _darkroom_pipeline_inputs_ready(const dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev)) return FALSE;
 
  dt_dev_image_geometry_t geometry;
  dt_dev_geometry_get(dev, &geometry);
 
  return dev->image_storage.id > 0
         && dt_dev_viewport_box_width(dev) >= 32
         && dt_dev_viewport_box_height(dev) >= 32
         && geometry.raw_width >= 32
         && geometry.raw_height >= 32
         && geometry.processed_width >= 32
         && geometry.processed_height >= 32
         && dt_dev_roi_request_preview_width(dev) >= 32
         && dt_dev_roi_request_preview_height(dev) >= 32;
}
 
int dt_dev_get_thumbnail_size(dt_develop_t *dev)
{
  if(!dt_dev_geometry_raw_inited(dev) || !dt_dev_viewport_configured(dev)) return 1;
 
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const int32_t raw_width = geometry.raw_width;
  const int32_t raw_height = geometry.raw_height;
 
  /* The chain is rebuilt BEFORE the size is decided now, because it is what decides it. It is
   * cheap -- small derivations of already-committed parameters, no LUT, no colour transform, no
   * disk -- which is the whole point of the exercise: the resync below is not. */
  const double chain_start = dt_get_wtime();
  dt_geometry_chain_rebuild(dev);
  const double chain_ms = (dt_get_wtime() - chain_start) * 1000.0;
 
  /* The developed size, folded from the geometry records. Nothing is rebuilt to obtain it: that
   * is what this service replaced, and what it cost is recorded in doc/geometry-service.md. */
  int processed_width = 0;
  int processed_height = 0;
  if(!dt_geometry_chain_processed_size(dev->geometry_chain, &processed_width, &processed_height))
    return 1;
 
  dt_dev_geometry_set_processed_size(dev, processed_width, processed_height);
 
  // Derive and publish everything the pipes plan from, as one record.
  dt_dev_roi_request_publish(dev);
 
  /* Shadow mode compares against the pipe's own fold, which only exists when the pipe was
   * resynced above -- so it is asked for, and paid for, under `-d dev' and nowhere else. It runs
   * STRICTLY AFTER both publications and never between them: those two are one atomic-looking
   * update, the first moving the geometry record to the new size and the second moving the ROI
   * request to match AND flagging the pipes to replan. Anything inserted between them widens the
   * window in which the darkroom worker latches the OLD request against ALREADY NEW history,
   * which is the mixed frame of #1157. An observer must not sit inside the update it observes. */
  dt_geometry_self_check(dev, chain_ms);
 
 
  dt_dev_update_mouse_effect_radius(dev);
 
  const dt_dev_roi_request_t request = dt_dev_roi_request_get(dev);
 
  dt_print(DT_DEBUG_DEV,
            "[pixelpipe] thumbnail sizes raw %dx%d -> processed %dx%d -> preview %dx%d (scale %.5f)\n",
            raw_width, raw_height, request.processed_width, request.processed_height,
            request.preview_width, request.preview_height, request.natural_scale);
  
  return 0;
}
 
gboolean dt_dev_pixelpipe_has_preview_output(const dt_develop_t *dev, const dt_dev_pixelpipe_t *pipe,
                                             const dt_iop_roi_t *roi)
{
  // The NULL checks come FIRST: this is called with dev->preview_pipe, which is allocated only
  // for a gui_attached dev (dt_dev_init) and is therefore NULL on every export and thumbnail
  // dev -- iop/denoiseprofile.c passes exactly that.
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(pipe) || !dev->gui_attached) return FALSE;
 
  // Compare against what this pipe was planned from, not what the GUI has published since.
  const dt_dev_roi_request_t request = dt_dev_roi_request_of_pipe(pipe);
  if(!request.valid) return FALSE;
 
  int x = 0;
  int y = 0;
  int width = 0;
  int height = 0;
  float scale = request.natural_scale;
 
  if(!IS_NULL_PTR(roi))
  {
    x = roi->x;
    y = roi->y;
    width = roi->width;
    height = roi->height;
    scale = roi->scale;
  }
  else
  {
    // Recompute the current darkroom output geometry so callers that run ahead of process()
    // still classify the pipe from the image they are about to produce, not the last backbuffer.
    _update_darkroom_roi((dt_develop_t *)dev, (dt_dev_pixelpipe_t *)pipe, &x, &y, &width, &height, &scale);
  }
 
  // A module upstream of the orientation swap (the "flip" module) — e.g. ashift, demosaic,
  // highlights — produces output whose width/height are swapped relative to the final, post-flip
  // preview dimensions on portrait images. Accept that swapped match too: otherwise the
  // "is this the full preview image?" test wrongly fails for every pre-flip module on portrait,
  // and `roi` here is the module's own (pre-flip) `roi_out`. This is why ashift never captured its
  // GUI buffer on portrait images, breaking structure detection and manual drawing (#710).
  //
  // Tolerate a couple of pixels of slack on the dimensions. `dev->roi.preview_*` is derived from the
  // composed geometry at scale 1.0, whereas `roi` is produced at `natural_scale`; geometric modules
  // (ashift, lens) round their transformed bounding box with floorf() independently at each scale,
  // so the two legitimately disagree by ~1px for the very same full image. The real discriminators
  // are the origin and scale tests below: a zoomed or panned ROI has a non-zero x/y and a scale
  // strictly greater than natural_scale, so loosening the size match cannot misclassify those.
  const int tol = 2;
  const gboolean dims_match
      = (abs(width - request.preview_width) <= tol && abs(height - request.preview_height) <= tol)
        || (abs(width - request.preview_height) <= tol && abs(height - request.preview_width) <= tol);
  if(!dims_match) return FALSE;
  return x == 0 && y == 0 && fabsf(scale - request.natural_scale) < 1e-4f;
}
 
 
// Return TRUE if ROI changed since previous computation
static gboolean _update_darkroom_roi(dt_develop_t *dev, dt_dev_pixelpipe_t *pipe, int *x, int *y, int *wd, int *ht,
                                     float *scale)
{  
  // The latched snapshot, not the live record: this runs on the worker, and the frame must be
  // planned from the same numbers the rest of this iteration uses.
  const dt_dev_roi_request_t request = dt_dev_roi_request_of_pipe(pipe);
  if(!request.valid) return 1;
 
  // Store previous values
  int x_old = *x;
  int y_old = *y;
  int wd_old = *wd;
  int ht_old = *ht;
  float old_scale = *scale;
 
  // roi->scale is the pipeline sampling ratio against the processed image and
  // therefore excludes the GUI backing-store density.
  *scale = request.natural_scale;
  const gboolean preview_pipe = (pipe == dev->preview_pipe);
  if(!preview_pipe) *scale *= request.scaling;
 
  // Width, height, x and y are already expressed in raster pixels, so they
  // must follow the same raster-space sampling ratio as roi->scale. All of it comes from the
  // latched record: mixing one live read into this arithmetic is exactly how a frame ends up
  // describing a viewport that never existed.
  int roi_width = roundf(*scale * request.processed_width);
  int roi_height = roundf(*scale * request.processed_height);
  int widget_wd = request.box_width;
  int widget_ht = request.box_height;
 
  *wd = roundf(fminf(roi_width, widget_wd));
  *ht = roundf(fminf(roi_height, widget_ht));
 
  // dt_dev_viewport_center_x(dev),y are the relative coordinates of the ROI center.
  // in preview pipe, we always render a full image, so x,y = 0,0 
  // otherwise, x,y here are the top-left corner. Translate:
  *x = preview_pipe ? 0 : roundf(request.center_x * roi_width - *wd * .5f);
  *y = preview_pipe ? 0 : roundf(request.center_y * roi_height - *ht * .5f);
 
/*  fprintf (stderr, "_update_darkroom_roi: dev %.2f %.2f  type %s  xy %d %d  dim %d %d"
                   "   ppd:%.4f scale:%.4f nat_scale:%.4f * scaling:%.4f\n",
            dt_dev_viewport_center_x(dev), dt_dev_viewport_center_y(dev), dt_pipe_type_to_str(pipe->type), *x, *y, *wd, *ht, dt_gui_get_global()->ppd, *scale, dt_dev_roi_request_natural_scale(dev), dt_dev_viewport_scaling(dev));
*/
  return x_old != *x || y_old != *y || wd_old != *wd || ht_old != *ht || old_scale != *scale;
}
 
gboolean dt_dev_pipelines_share_preview_output(dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev) || !dev->gui_attached || IS_NULL_PTR(dev->pipe) || IS_NULL_PTR(dev->preview_pipe) || !dt_dev_roi_request_valid(dev)) return FALSE;
 
  float preview_scale = 1.0f;
  float main_scale = 1.0f;
  int preview_x = 0, preview_y = 0, preview_wd = 0, preview_ht = 0;
  int main_x = 0, main_y = 0, main_wd = 0, main_ht = 0;
 
  _update_darkroom_roi(dev, dev->preview_pipe, &preview_x, &preview_y, &preview_wd, &preview_ht, &preview_scale);
  _update_darkroom_roi(dev, dev->pipe, &main_x, &main_y, &main_wd, &main_ht, &main_scale);
 
  return preview_x == main_x && preview_y == main_y && preview_wd == main_wd && preview_ht == main_ht
         && fabsf(preview_scale - main_scale) < 1e-4f;
}
 
 
static void dt_dev_resync_mipmap_cache(dt_develop_t *dev, dt_dev_pixelpipe_t *pipe, dt_iop_roi_t roi)
{
  const int32_t imgid = pipe->dev->image_storage.id;
 
  // Get the mip size that is at most as big as our pipeline backbuf. One read: these dimensions
  // are handed to the mipmap cache alongside the payload below, so they must describe it.
  const dt_backbuf_state_t published = dt_dev_backbuf_snapshot(&pipe->backbuf);
  dt_mipmap_size_t mip = dt_mipmap_cache_get_fitting_size(published.width, published.height, imgid);
  
  // Flush backup to mipmap_cache. This runs after dt_dev_pixelpipe_process() released the OpenCL device
  // lock, so we must NOT pass pipe->devid (now stale/unlocked): a device-only payload would otherwise be
  // materialized from the GPU without owning it. The final display backbuffer is always host-resident,
  // so preferred_devid = -1 returns it directly; anything else is simply skipped.
  uint8_t *data = NULL;
  dt_pixel_cache_entry_t *entry = NULL;
  if(dt_dev_pixelpipe_cache_ref_entry_by_hash(dt_dev_pixelpipe_get_hash(pipe), (void **)&data, &entry)
     && data)
  {
    dt_dev_pixelpipe_cache_rdlock_entry(TRUE, entry);
    dt_colorprofiles_settings_t settings;
    dt_colorprofiles_get_settings(&settings);
    dt_mipmap_cache_swap_at_size(imgid, mip, data, published.width, published.height,
                                 settings.display_type);
    dt_dev_pixelpipe_cache_rdlock_entry(FALSE, entry);
    dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
  }
  else if(entry)
  {
    dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
  }
}
 
gboolean _resync_pipe_with_history(dt_develop_t *dev, dt_dev_pixelpipe_t *pipe, dt_iop_roi_t *roi, gboolean *needs_update)
{
  // When in realtime mode, preview pipe gets paused at the benefit of main pipeline.
  // This is a transient state.
  if(dt_atomic_get_int(&pipe->pause)) return FALSE;
 
  // We recompute if history hash changed or ROI has changed.
  // If we know history changed, ensure at least the last step is resynced.
  const uint64_t pipe_hash = dt_dev_pixelpipe_get_history_hash(pipe);
  const uint64_t dev_hash = dt_dev_get_history_hash(dev);
  if(pipe_hash != dev_hash)
  {
    dt_dev_pixelpipe_or_changed(pipe, DT_DEV_PIPE_TOP_CHANGED);
    dt_print(DT_DEBUG_PIPE | DT_DEBUG_DEV, "dev history hash = %" PRIu64 ", pipe history hash %" PRIu64 "\n", dev_hash, pipe_hash);
  }
 
  *needs_update = (dt_dev_pixelpipe_get_changed(pipe) != DT_DEV_PIPE_UNCHANGED);
  if(!*needs_update) return FALSE;
 
  dt_pthread_mutex_lock(&pipe->busy_mutex);
  pipe->processing = 1;
 
  // Commit history to pipeline.
  // This can take 40-80 ms or much more with masks on weak hardware,
  // so user may have changed the history again during that lapse.
  gboolean pipe_resynced = FALSE;
  while(dt_dev_pixelpipe_get_changed(pipe) != DT_DEV_PIPE_UNCHANGED)
  {
    dt_dev_pixelpipe_change(pipe);
    pipe_resynced = TRUE;
  }
 
  // Plan the ROI for this run and finalize the cumulative global hash now, while the pipe is
  // settled and not yet publishing pixels. dt_dev_pixelpipe_process() recomputes both at its
  // entry (it is also called directly by export/snapshot pipes), but computing them here is
  // what lets the HISTORY_RESYNC signal below advertise a hash that is already final.
  int x = 0, y = 0, wd = 0, ht = 0;
  float scale = 1.f;
  _update_darkroom_roi(dev, pipe, &x, &y, &wd, &ht, &scale);
  *roi = (dt_iop_roi_t){ x, y, wd, ht, scale };
  dt_dev_pixelpipe_get_roi_in(pipe, *roi);
  dt_pixelpipe_get_global_hash(pipe);
 
  pipe->processing = 0;
  dt_pthread_mutex_unlock(&pipe->busy_mutex);
 
  return pipe_resynced;
}
 
 
void dt_dev_darkroom_pipeline(dt_develop_t *dev)
{
  dt_dev_pixelpipe_t *const pipes[] = { dev->preview_pipe, dev->pipe };
 
  for(size_t i = 0; i < G_N_ELEMENTS(pipes); i++)
    dt_atomic_set_int(&pipes[i]->running, TRUE);
 
  // Infinite loop: run for as long as the worker thread is running.
  while(!dev->exit && dt_control_running())
  {
    if(!_darkroom_pipeline_inputs_ready(dev))
    {
      dt_iop_nap(50000); // wait 50 ms until GUI/image sizes are initialized
      continue;
    }
 
    // Latch the viewport request ONCE for this iteration, before anything reads it. Everything
    // downstream -- the ROI planner, the resync, every module callback -- then works from one
    // snapshot for the whole frame, however many times the GUI thread republishes meanwhile.
    // Reading it live at each consumer is what let a single frame be planned from two different
    // viewport states.
    const dt_dev_roi_request_t latched = dt_dev_roi_request_get(dev);
    for(size_t i = 0; i < G_N_ELEMENTS(pipes); i++)
      dt_dev_roi_request_latch(pipes[i], &latched);
 
    // This is cheap to run, keep it in sync always.
    const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
    const int32_t input_width = geometry.raw_width;
    const int32_t input_height = geometry.raw_height;
    for(size_t i = 0; i < G_N_ELEMENTS(pipes); i++)
      dt_dev_pixelpipe_set_input(pipes[i], dev->image_storage.id, input_width, input_height,
                                 1.0f, DT_MIPMAP_FULL);
 
    gboolean pipe_needs_update[G_N_ELEMENTS(pipes)] = { FALSE };
    dt_iop_roi_t pipe_roi[G_N_ELEMENTS(pipes)] = { { 0 } };
    gboolean history_resynced = FALSE;
 
    // First, resynchronize all dirty pipelines from history, plan their ROI and finalize their
    // cumulative global hash, so GUI listeners can resolve stable piece->global_hash values
    // before any cacheline starts publishing pixels.
    for(size_t i = 0; i < G_N_ELEMENTS(pipes); i++)
      history_resynced |= _resync_pipe_with_history(dev, pipes[i], &pipe_roi[i], &pipe_needs_update[i]);
 
    // NOTE: at this point, we fully know the state of __all__ our GUI pipelines :
    // - global image input and output size,
    // - per-module input and output size,
    // - per-module input and output format (channels, bit depth, mosaiced/raster, CFA pattern)
    // - pipeline nodes (modules) params are up-to-to date with history,
    // - global_hash of each module is and stable until next history resync,
    // - modules whose expected input format is incompatible with previous module output format
    //   will have been disabled from pipeline, but not from history, aka we know our pipelines
    //   can run start to end.
 
    // GUI widgets that need an image buffer will connect to this signal to grab
    // the global_hash of the module they are waiting for, even though it's still not ready.
    if(history_resynced)
      DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_HISTORY_RESYNC);
 
    // Second, compute pipelines.
    // Always service preview first, then the main pipe, so the main pipe can reuse the cache state
    // just published by preview instead of trying to race it from another thread.
    for(size_t i = 0; i < G_N_ELEMENTS(pipes) && dt_control_running() && !dev->exit; i++)
    {
      if(!pipe_needs_update[i]) continue;
 
      dt_dev_pixelpipe_t *pipe = pipes[i];
      const dt_iop_roi_t roi = pipe_roi[i];
 
      // The resync stage above synchronized history, planned the ROI and advertised the matching
      // final global hash. We process the exact state it committed, using pipe_roi[i]: that is what
      // dt_dev_pixelpipe_process() recomputes its hash from, so the cacheline it publishes always
      // carries the hash already announced to GUI consumers. A change that lands after this point
      // raises the killswitch together with its changed flag (`_change_pipe()`, and
      // dt_dev_roi_request_publish() does the same on a payload change), so the run below aborts
      // and the next loop iteration resyncs, re-advertises and reprocesses the new state. We must
      // NOT skip on a set changed flag here: every darkroom configure-event flags the preview pipe
      // ZOOMED, so on an image switch (which re-lays-out the view) skipping would starve the
      // preview and leave navigation/scopes blank.
      //
      // A change that landed BETWEEN this iteration's latch and this point is another matter, and
      // the check below is the second half of the #1157 fix. The resync's while(changed) loop
      // spans 100-400 ms and consumes whatever flags land inside it, syncing their history -- but
      // the ROI was then planned from THIS ITERATION'S latch, taken before any of it. Their
      // killswitch does not save the run either, since the reset a few lines down would swallow
      // it. Rendering the consumed history into the stale latched geometry is how a crop Apply
      // produced a border-clamped smear that nothing ever corrected. So: if the published record
      // has moved past the latch, this plan is dead. Re-flag (the flag may have been consumed) and
      // skip the run; the next iteration re-latches and replans from the current record. This
      // cannot starve: the generation only advances when a GUI publish actually changed the
      // payload, so a quiet viewport lets the very next iteration through.
      const dt_dev_roi_request_t current_request = dt_dev_roi_request_get(dev);
      if(current_request.generation != latched.generation)
      {
        dt_dev_pixelpipe_or_changed(pipe, DT_DEV_PIPE_ZOOMED);
        continue;
      }
 
      // Both pipes were resynced before the preview ran, so a history change committed while the
      // preview was running (a module switched off mid-render, #1519) finds the main pipe planned
      // from the old history: its killswitch is raised and its changed flag left set. The reset
      // below would swallow that killswitch and render the stale history to completion, heavy
      // modules included. The flag survives the skip, so the next iteration resyncs and runs the
      // current state. Main pipe only: the preview runs first, right after the resync, and the
      // configure-event ZOOMED flag landing inside that resync must not starve it (see above).
      if(pipe == dev->pipe && dt_atomic_get_int(&pipe->shutdown)
         && dt_dev_pixelpipe_get_changed(pipe) != DT_DEV_PIPE_UNCHANGED)
        continue;
 
      dt_print(DT_DEBUG_PIPE | DT_DEBUG_DEV, "PIPE %s needs update\n", pipe->type == DT_DEV_PIXELPIPE_FULL ? "full" : "preview");
 
      dt_pthread_mutex_lock(&pipe->busy_mutex);
      pipe->processing = 1;
 
      // We are starting fresh, reset the killswitch signal. Safe only because the staleness
      // check above ran after the resync: any killswitch this discards belonged to a change
      // whose flag either survives (raised after the resync loop exited) or whose publish
      // moved the generation (caught above). Do not move this reset earlier.
      dt_atomic_set_int(&pipe->shutdown, FALSE);
 
      const gboolean retrying_raster_mask = dt_dev_pixelpipe_has_reentry(pipe);
 
      // Whether the recompute was triggered because we needed only the output of 
      // a specified module, or we needed the output backbuf of the whole pipeline.
      // This allows partial pipeline runs, e.g. for histograms and color-pickers.
      const dt_dev_pixelpipe_cache_request_t cache_request = dt_dev_pixelpipe_get_cache_request(pipe);
 
      // At zoom == fit, both preview and main pipelines have the same size,
      // so the first one that runs will prevent the next from running 
      // (backbuf fetched directly from pipeline cache).
      // Therefore we can't rely solely on pipeline type to raise completion signals.
      const gboolean has_preview_size = dt_dev_pixelpipe_has_preview_output(dev, pipe, &roi);
 
      const gboolean requested_mask_preview
          = pipe == dev->pipe
            && !IS_NULL_PTR(dev->gui_module)
            && dev->gui_module->request_mask_display != DT_DEV_PIXELPIPE_DISPLAY_NONE;
 
      dt_colorprofiles_settings_t profile_settings;
      dt_colorprofiles_get_settings(&profile_settings);
      const gboolean requested_overlay
          = pipe == dev->pipe
            && (dev->overexposed.enabled || dev->rawoverexposed.enabled
                || profile_settings.mode != DT_PROFILE_NORMAL);
 
      // Connect GUI feedback for "pipe busy"
      dt_control_log_busy_enter();
      dt_control_toast_busy_enter();
      dev->progress.completed = 0;
      dev->progress.total = 0;
 
      dt_times_t thread_start;
      dt_get_times(&thread_start);
 
      // The actual processing with runtime log
      const gint64 process_start_us = g_get_monotonic_time();
      const int ret = dt_dev_pixelpipe_process(pipe, roi);
      const gint64 process_runtime_us = g_get_monotonic_time() - process_start_us;
 
      // Print perf log
      gchar *msg = g_strdup_printf("[dev_process_%s] pipeline processing thread", 
                                   dt_pixelpipe_get_pipe_name(pipe->type));
      dt_show_times(&thread_start, msg);
      dt_free(msg);
 
      // Disconnect GUI feedback for "pipe busy"
      dev->progress.completed = 0;
      dev->progress.total = 0;
      dt_control_log_busy_leave();
      dt_control_toast_busy_leave();
 
      // Pipeline completed entirely without error
      const gboolean processed = (!ret && !dt_atomic_get_int(&pipe->shutdown));
 
      const gboolean published_backbuffer
          = processed && dt_dev_pixelpipe_is_backbufer_valid(pipe);
 
      // Pipeline reentry flag is set when we lost the reference to a raster mask.
      // This typically happens on re-entering darkroom after having gone to lighttable:
      // the pipeline cache is kept but the references to raster masks are flushed,
      // so the pipeline recomputation resumes downstream from the last-known cacheline,
      // which may not refresh raster masks if produced upstream in pipeline.
      // TODO: cache raster masks too (was attempted before, and failed).
      if(dt_dev_pixelpipe_has_reentry(pipe))
      {
        if(retrying_raster_mask)
        {
          // Reentry flag was set already before last pipe run, which refreshed
          // everything we needed. We can resume to normal mode.
          // In case that wasn't true, it will be caught at the next run.
          dt_dev_pixelpipe_reset_reentry(pipe);
        }
        else
        {
          // Reentry flag was set during the last pipe run, which means we
          // lost at least a raster mask reference, and need to retry again
          // from the start.
          // The synchronized graph and its ROIs are still valid. The retry
          // only needs another processing pass after targeted cache
          // invalidation, not node destruction and history reconstruction.
          dt_dev_pixelpipe_or_changed(pipe, DT_DEV_PIPE_REENTRY);
        }
      }
 
      if(processed 
         && cache_request == DT_DEV_PIXELPIPE_CACHE_REQUEST_MODULE
         && !published_backbuffer)
      {
        if(dt_dev_pixelpipe_get_cache_request(pipe) == DT_DEV_PIXELPIPE_CACHE_REQUEST_NONE)
          dt_dev_pixelpipe_set_cache_request(pipe, DT_DEV_PIXELPIPE_CACHE_REQUEST_BACKBUF, NULL);
        dt_dev_pixelpipe_or_changed(pipe, DT_DEV_PIPE_CACHE_REQUEST);
      }
 
      pipe->processing = 0;
      dt_pthread_mutex_unlock(&pipe->busy_mutex);
 
      // Update the running average of process time for GUI controls thresholding
      if(processed)
      {
        // Map the pipe onto the throttle's own two slots; it does not know pipeline types.
        const dt_throttle_slot_t slot = (pipe->type == DT_DEV_PIXELPIPE_FULL) ? DT_THROTTLE_SLOT_MAIN
                                        : (pipe->type == DT_DEV_PIXELPIPE_PREVIEW) ? DT_THROTTLE_SLOT_PREVIEW
                                        : DT_THROTTLE_SLOT_OTHER;
        dt_gui_throttle_record_runtime(slot, process_runtime_us);
      }
 
      // If everything went well, yell to GUI listeners that they can use the output buffer.
      if(published_backbuffer)
      {
        if(pipe->type == DT_DEV_PIXELPIPE_FULL)
        {
          DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_UI_PIPE_FINISHED);
          dt_control_queue_redraw_center();
        }
        if(pipe->type == DT_DEV_PIXELPIPE_PREVIEW || has_preview_size)
        {
          DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_PREVIEW_PIPE_FINISHED);
          dt_control_queue_redraw();
        }
 
        if(!dt_dev_pixelpipe_get_realtime(pipe)
           && has_preview_size
           && !requested_mask_preview
           && !requested_overlay
           && pipe->mask_display == DT_DEV_PIXELPIPE_DISPLAY_NONE)
          dt_dev_resync_mipmap_cache(dev, pipe, roi);
      }
 
      /* Breathing room for the OS and the GPU, sized against the work just done rather than
       * fixed. A realtime stroke paces itself upstream -- the publisher only republishes once
       * per measured pipe runtime -- so a constant here is not what stops this loop spinning;
       * it is pure latency added to every frame. Two 10 ms naps were ~15% of a 130 ms frame
       * when this was written and are 41% of a 29 ms one, which is how a constant ages when
       * the thing it sits beside gets three times faster. */
      if(!dt_dev_pixelpipe_get_realtime(pipe)) dt_iop_nap(10000);
    }
 
    /* Nap only when this turn found nothing to do. Having serviced a pipe, go straight back and
     * look again: the publish throttle decides how often there is new work, and sleeping past
     * its next publish just moves the stroke further behind the pointer. */
    const gboolean serviced = pipe_needs_update[0] || pipe_needs_update[1];
    if(dt_dev_pixelpipe_get_realtime(pipes[0]) || dt_dev_pixelpipe_get_realtime(pipes[1]))
      dt_iop_nap(serviced ? 500 : 10000);
    else
      dt_iop_nap(serviced ? 1000 : 50000);
  }
 
  for(size_t i = 0; i < G_N_ELEMENTS(pipes); i++)
    dt_atomic_set_int(&pipes[i]->running, FALSE);
}
 
static int32_t dt_dev_process_job_run(dt_job_t *job)
{
  dt_develop_t *dev = dt_control_job_get_params(job);
  dt_dev_darkroom_pipeline(dev);
  return 0;
}
 
dt_job_t *dt_dev_process_job_create(dt_develop_t *dev)
{
  dt_job_t *job = dt_control_job_create(&dt_dev_process_job_run, "develop process image");
  if(IS_NULL_PTR(job)) return NULL;
  dt_control_job_set_params(job, dev, NULL);
  return job;
}
 
void dt_dev_start_all_pipelines(dt_develop_t *dev)
{
  if(dev->pipelines_started) return;
  dt_control_add_job_res(dt_control_get_global(), dt_dev_process_job_create(dev), DT_CTL_WORKER_DARKROOM);
  dev->pipelines_started = TRUE;
}
 
static gboolean _dt_dev_mipmap_prefetch_full(dt_develop_t *dev, const int32_t imgid)
{
  dt_mipmap_buffer_t buf;
  dt_mipmap_cache_get(&buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING, 'r');
 
  const gboolean ok = (!IS_NULL_PTR(buf.buf)) && buf.width != 0 && buf.height != 0;
 
  // dt_dev_geometry_raw_width(dev)/height are the raw image's own pixel dimensions -- an objective fact
  // about the loaded buffer, not GUI viewport state -- and must be set for every dev, not just
  // gui_attached ones. dt_dev_coordinates_raw_norm_to_raw_abs() (develop.c) and every drawn-mask
  // shape's own geometry function (masks/circle.c, ellipse.c, brush.c, gradient.c, polygon.c) read
  // dt_dev_geometry_raw_width(dev)/height to convert a form's normalized center/points into absolute pixel
  // coordinates; with raw_width/height left at 0 (their calloc default), that conversion silently
  // no-ops (dt_dev_coordinates_raw_norm_to_raw_abs() early-returns on raw_width==0), leaving the
  // shape's normalized (0..1) coordinates masquerading as pixel coordinates -- collapsing every
  // shape's computed position to somewhere near the image origin regardless of where it was
  // actually drawn. That made every drawn mask on any non-GUI dev (export, thumbnail generation,
  // dev_snapshot.c's frozen dev) resolve to the wrong location, so a module needing mask history
  // (retouch's clone/heal/blur/fill, or any masked blend) either processes empty geometry or
  // silently produces zero visible effect outside the live darkroom.
  // Publish what the read actually produced. `ok' is FALSE when the mipmap cache handed back
  // no buffer or a 0-sized one; claiming raw_inited in that case told every later reader that
  // 0x0 was a measured fact about the image, and dt_dev_geometry_refresh()'s own guard
  // (dt_dev_geometry_raw_inited) then let the size fold run on it.
  dt_dev_geometry_set_raw_size(dev, ok ? buf.width : 0, ok ? buf.height : 0, ok);
 
  /* The entry could not be allocated just now. A decode that ran out of memory leaves an entry
   * behind, and dt_imageio_open() says so itself, in the same window. */
  if(IS_NULL_PTR(buf.cache_entry) && buf.status == DT_IMAGEIO_CACHE_FULL)
  {
    char path[DT_PATH_MAX] = { 0 };
    dt_image_full_path(imgid, path, sizeof(path), NULL, __FUNCTION__);
    dt_control_alert_once(_("Not enough memory"),
                          _("Not enough memory to load the image at full size.\n"
                            "Close other applications or add more RAM to your system."),
                          path[0] ? path : NULL);
  }
 
  dt_mipmap_cache_release(&buf);
 
  return ok;
}
 
static gboolean _dt_dev_refresh_image_storage(dt_develop_t *dev, const int32_t imgid)
{
  const dt_image_t *image = dt_image_cache_get(imgid, 'r');
  if(IS_NULL_PTR(image)) return FALSE;
  dev->image_storage = *image;
  dt_image_cache_read_release(image);
  dt_iop_buffer_dsc_update_bpp(&dev->image_storage.dsc);
  return TRUE;
}
 
dt_dev_image_storage_t dt_dev_ensure_image_storage(dt_develop_t *dev, const int32_t imgid)
{
  if(IS_NULL_PTR(dev) || imgid <= 0 || !dt_image_cache_is_ready())
    return DT_DEV_IMAGE_STORAGE_DB_NOT_READ;
 
  if(!_dt_dev_mipmap_prefetch_full(dev, imgid))
    return DT_DEV_IMAGE_STORAGE_MIPMAP_NOT_FOUND;
 
  if(!_dt_dev_refresh_image_storage(dev, imgid)) 
    return DT_DEV_IMAGE_STORAGE_DB_NOT_READ;
 
  return DT_DEV_IMAGE_STORAGE_OK;
}
 
// load the raw and get the new image struct, blocking in gui thread
static inline dt_dev_image_storage_t _dt_dev_load_raw(dt_develop_t *dev, const int32_t imgid)
{
  // then load the raw
  dt_times_t start;
  dt_get_times(&start);
 
  // Test we got images. Also that populates the cache for later.
  // Refresh our private copy in case raw loading updated image metadata
  const dt_dev_image_storage_t storage_status = dt_dev_ensure_image_storage(dev, imgid);
  if(storage_status) 
    return storage_status;
  
  dt_show_times_f(&start, "[dev_pixelpipe]", "to load the image.");
 
  return storage_status;
}
 
// return the zoom scale to fit into the viewport
float dt_dev_get_zoom_scale(const dt_develop_t *dev, const gboolean preview)
{
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const int32_t processed_width = geometry.processed_width;
  const int32_t processed_height = geometry.processed_height;
 
  const float w = preview ? processed_width : dev->pipe->processed_width;
  const float h = preview ? processed_height : dev->pipe->processed_height;
  return fminf(dt_dev_viewport_box_width(dev) / w, dt_dev_viewport_box_height(dev) / h);
}
 
dt_dev_image_storage_t dt_dev_load_image(dt_develop_t *dev, const int32_t imgid)
{
  const dt_dev_image_storage_t ret = _dt_dev_load_raw(dev, imgid);
  if(ret) return ret;
 
  // we need a global lock as the dev->iop set must not be changed until read history is terminated
  dt_pthread_rwlock_wrlock(&dev->history_mutex);
 
  const gboolean first_run = dt_dev_read_history_ext(dev, imgid);
 
  if(first_run && dev == dt_dev_get_global())
  {
    // Resync our private copy of image image with DB,
    // mostly for DT_IMAGE_AUTO_PRESETS_APPLIED flag.
    dt_image_t *image = dt_image_cache_get(imgid, 'w');
    if(!IS_NULL_PTR(image))
    {
      *image = dev->image_storage;
      dt_image_cache_write_release(image, DT_IMAGE_CACHE_SAFE);
    }
 
    dt_dev_write_history_ext(dev, imgid);
  }
 
  dt_pthread_rwlock_unlock(&dev->history_mutex);
 
  if(first_run && dev == dt_dev_get_global())
  {
    dt_dev_append_changed_tag(imgid);
    dt_dev_history_notify_change(dev, imgid);
  }
 
  return ret;
}
 
void dt_dev_configure_real(dt_develop_t *dev, int wd, int ht)
{
  // Called only from Darkroom to convert the widget allocation into the
  // raster ROI contract consumed by the pipeline. Everything stored in
  // dev->roi below is expressed in real buffer pixels.
  const dt_iop_roi_t gui_roi = { .x = 0, .y = 0, .width = wd, .height = ht, .scale = 1.0f };
  dt_iop_roi_t pipe_roi = { 0 };
  dt_dev_convert_roi(dev, &gui_roi, &pipe_roi, DT_DEV_ROI_GUI_LOGICAL, DT_DEV_ROI_PIPELINE);
 
  /* A configure that changes nothing does nothing. GTK delivers a configure-event to the centre
   * whenever its window is allocated again, and a layout pass runs whenever any widget's size
   * request changes -- the theme gives every hovered tab and button a heavier font weight, so
   * that is every hover. The box is what the pipes plan from; when it comes back the same as
   * the one already published there is nothing to re-plan, no thumbnail size to recompute, and
   * no reason to redraw the whole window (every panel, the navigation, the scopes). Only the
   * first configure and a real size, border or zoom change get past this. */
  if(!dt_dev_viewport_set_box(dev, pipe_roi.width, pipe_roi.height))
  {
    dt_print(DT_DEBUG_DEV, "[pixelpipe] Darkroom requested a %i×%i px widget -> %i×%i px raster preview, unchanged\n",
             wd, ht, dt_dev_viewport_box_width(dev), dt_dev_viewport_box_height(dev));
    return;
  }
 
  dt_print(DT_DEBUG_DEV,
           "[pixelpipe] Darkroom requested a %i×%i px widget -> %i×%i px raster preview\n",
           wd, ht, dt_dev_viewport_box_width(dev), dt_dev_viewport_box_height(dev));
 
  dt_dev_get_thumbnail_size(dev);
  dt_dev_pixelpipe_update_zoom_main(dev);
  dt_dev_pixelpipe_update_zoom_preview(dev);
  dt_control_queue_redraw();
}
 
gboolean dt_dev_clamp_viewport_center(dt_develop_t *dev)
{
  const dt_dev_viewport_state_t viewport = dt_dev_viewport_get(dev);
  float center_x = viewport.center_x;
  float center_y = viewport.center_y;
  dt_dev_check_zoom_pos_bounds(dev, &center_x, &center_y, NULL, NULL);
  return dt_dev_viewport_set_center(dev, center_x, center_y);
}
 
void dt_dev_check_zoom_pos_bounds(dt_develop_t *dev, float *dev_x, float *dev_y, float *box_w, float *box_h)
{
  // for the debug strings lower
  //float old_x = *dev_x;
  //float old_y = *dev_y;
  int proc_w = 0;
  int proc_h = 0;
  dt_dev_get_processed_size(dev, &proc_w, &proc_h);
  const float scale = dt_dev_get_zoom_level(dev);
 
  // find the box size
  const float bw = dt_dev_viewport_box_width(dev) / (proc_w * scale);
  const float bh = dt_dev_viewport_box_height(dev) / (proc_h * scale);
 
  // calculate half-dimensions once
  const float half_bw = bw * 0.5f;
  const float half_bh = bh * 0.5f;
 
  // clamp position using pre-calculated values
  *dev_x = (bw > 1.0f || dt_dev_viewport_scaling(dev) <= 1.0f) ? 0.5f : CLAMPF(*dev_x, half_bw, 1.0f - half_bw);
  *dev_y = (bh > 1.0f || dt_dev_viewport_scaling(dev) <= 1.0f) ? 0.5f : CLAMPF(*dev_y, half_bh, 1.0f - half_bh);
  // return box size
  if(!IS_NULL_PTR(box_w)) *box_w = bw;
  if(!IS_NULL_PTR(box_h)) *box_h = bh;
 
  /*
  fprintf(stdout, "BOUNDS: box size: %2.2f x %2.2f\n", bw, bh);
  fprintf(stdout, "BOUNDS: half box size: %2.2f x %2.2f\n", half_bw, half_bh);
  fprintf(stdout, "BOUNDS: X pos: %2.2f -> %2.2f [%2.2f %2.2f]\n",
    old_x, *dev_x, half_bw, 1.0f - half_bw);
  fprintf(stdout, "BOUNDS: Y pos: %2.2f -> %2.2f [%2.2f %2.2f]\n",
    old_y, *dev_y, half_bh, 1.0f - half_bh);
*/
}
 
void dt_dev_get_processed_size(const dt_develop_t *dev, int *procw, int *proch)
{
  // Write the outputs on EVERY path. Callers declare them uninitialized and read them straight
  // back -- iop/crop.c's _aspect_apply() does `int iwd, iht; dt_dev_get_processed_size(...);
  // if(iwd < iht)` -- so returning without writing hands them whatever was on the stack. Zero
  // is not a meaningful size, but it is a deterministic one, and it is what those callers
  // already behave sanely for; garbage is what they could not.
  if(!IS_NULL_PTR(procw)) *procw = 0;
  if(!IS_NULL_PTR(proch)) *proch = 0;
 
  if(IS_NULL_PTR(dev)) return;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const int32_t processed_width = geometry.processed_width;
  const int32_t processed_height = geometry.processed_height;
  if(!IS_NULL_PTR(procw)) *procw = processed_width;
  if(!IS_NULL_PTR(proch)) *proch = processed_height;
}
 
void dt_dev_coordinates_widget_delta_to_image_delta(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
 
  const float scale = dt_dev_get_zoom_level(dev) / dt_gui_get_global()->ppd;
  if(scale == 0.0f) return;
 
  // Widget deltas are measured in Gtk logical pixels. Convert them to processed-image
  // pixels here so dragging thresholds and keyboard pans share the same zoom math.
  for(size_t i = 0; i < num_points; ++i)
  {
    const size_t idx = i * 2;
    points[idx + 0] /= scale;
    points[idx + 1] /= scale;
  }
}
 
void dt_dev_coordinates_widget_to_image_norm(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float processed_width = geometry.processed_width;
  const float processed_height = geometry.processed_height;
  if(processed_width == 0.0f || processed_height == 0.0f) return;
 
  // Widget events are expressed in GUI logical coordinates, while the pipeline
  // zoom lives in raster pixels. Convert back to the same GUI-space zoom used
  // by dt_dev_rescale_roi() so event hit-testing and overlay drawing stay aligned.
  const float scale = dt_dev_get_zoom_level(dev) / dt_gui_get_global()->ppd;
  const float roi_x = (float)dt_dev_viewport_center_x(dev);
  const float roi_y = (float)dt_dev_viewport_center_y(dev);
  const float center_x = 0.5f * (float)dt_dev_viewport_widget_width(dev);
  const float center_y = 0.5f * (float)dt_dev_viewport_widget_height(dev);
  const float inv_scaled_width = 1.0f / (processed_width * scale);
  const float inv_scaled_height = 1.0f / (processed_height * scale);
 
  for(size_t i = 0; i < num_points; ++i)
  {
    const size_t idx = i * 2;
    const float px = points[idx + 0];
    const float py = points[idx + 1];
    points[idx + 0] = roi_x + (px - center_x) * inv_scaled_width;
    points[idx + 1] = roi_y + (py - center_y) * inv_scaled_height;
  }
}
 
void dt_dev_coordinates_image_norm_to_widget(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float processed_width = geometry.processed_width;
  const float processed_height = geometry.processed_height;
  if(processed_width == 0.0f || processed_height == 0.0f) return;
 
  // GUI overlays are drawn in logical widget coordinates, so use the same
  // GUI-space zoom that the Cairo darkroom transform applies.
  const float scale = dt_dev_get_zoom_level(dev) / dt_gui_get_global()->ppd;
  const float roi_x = (float)dt_dev_viewport_center_x(dev);
  const float roi_y = (float)dt_dev_viewport_center_y(dev);
  const float scaled_width = processed_width * scale;
  const float scaled_height = processed_height * scale;
  const float center_x = 0.5f * (float)dt_dev_viewport_widget_width(dev);
  const float center_y = 0.5f * (float)dt_dev_viewport_widget_height(dev);
 
  for(size_t i = 0; i < num_points; ++i)
  {
    const size_t idx = i * 2;
    const float px = points[idx + 0];
    const float py = points[idx + 1];
    const float dx = (px - roi_x) * scaled_width;
    const float dy = (py - roi_y) * scaled_height;
    points[idx + 0] = dx + center_x;
    points[idx + 1] = dy + center_y;
  }
}
 
void dt_dev_coordinates_image_norm_to_image_abs(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float processed_width = geometry.processed_width;
  const float processed_height = geometry.processed_height;
  if(processed_width == 0.0f || processed_height == 0.0f) return;
 
  for(size_t i = 0; i < num_points; ++i)
  {
    const size_t idx = i * 2;
    points[idx + 0] *= processed_width;
    points[idx + 1] *= processed_height;
  }
}
 
void dt_dev_coordinates_image_abs_to_image_norm(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float processed_width = geometry.processed_width;
  const float processed_height = geometry.processed_height;
  if(processed_width == 0.0f || processed_height == 0.0f) return;
 
  const float inv_width = 1.0f / processed_width;
  const float inv_height = 1.0f / processed_height;
  for(size_t i = 0; i < num_points; ++i)
  {
    const size_t idx = i * 2;
    points[idx + 0] *= inv_width;
    points[idx + 1] *= inv_height;
  }
}
 
void dt_dev_coordinates_raw_abs_to_raw_norm(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float raw_width = geometry.raw_width;
  const float raw_height = geometry.raw_height;
  if(raw_width == 0.0f || raw_height == 0.0f) return;
  
  const float inv_width = 1.f / raw_width;
  const float inv_height = 1.f / raw_height;
  for(size_t i = 0; i < num_points; i++)
  {
    const size_t idx = i * 2;
    points[idx + 0] *= inv_width;
    points[idx + 1] *= inv_height;
  }
}
 
void dt_dev_coordinates_raw_norm_to_raw_abs(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float raw_width = geometry.raw_width;
  const float raw_height = geometry.raw_height;
  if(raw_width == 0.0f || raw_height == 0.0f) return;
  
  for(size_t i = 0; i < num_points; i++)
  {
    const size_t idx = i * 2;
    points[idx + 0] *= raw_width;
    points[idx + 1] *= raw_height;
  }
}
 
void dt_dev_coordinates_image_norm_to_raw_norm(dt_develop_t *dev, float *points, size_t num_points)
{
  dt_dev_coordinates_image_norm_to_image_abs(dev, points, num_points);
  dt_dev_coordinates_image_abs_to_raw_abs(dev, points, num_points);
  dt_dev_coordinates_raw_abs_to_raw_norm(dev, points, num_points);
}
 
void dt_dev_coordinates_raw_norm_to_image_norm(dt_develop_t *dev, float *points, size_t num_points)
{
  dt_dev_coordinates_raw_norm_to_raw_abs(dev, points, num_points);
  dt_dev_coordinates_raw_abs_to_image_abs(dev, points, num_points);
  dt_dev_coordinates_image_abs_to_image_norm(dev, points, num_points);
}
 
void dt_dev_coordinates_image_abs_to_raw_norm(dt_develop_t *dev, float *points, size_t num_points)
{
  dt_dev_coordinates_image_abs_to_raw_abs(dev, points, num_points);
  dt_dev_coordinates_raw_abs_to_raw_norm(dev, points, num_points);
}
 
void dt_dev_coordinates_image_norm_to_preview_abs(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const float preview_width = dt_dev_roi_request_preview_width(dev);
  const float preview_height = dt_dev_roi_request_preview_height(dev);
  if(preview_width == 0.0f || preview_height == 0.0f) return;
  
  for(size_t i = 0; i < num_points; i++)
  {
    const size_t idx = i * 2;
    points[idx + 0] *= preview_width;
    points[idx + 1] *= preview_height;
  }
}
 
void dt_dev_coordinates_preview_abs_to_image_norm(dt_develop_t *dev, float *points, size_t num_points)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(points) || num_points == 0) return;
  const float preview_width = dt_dev_roi_request_preview_width(dev);
  const float preview_height = dt_dev_roi_request_preview_height(dev);
  if(preview_width == 0.0f || preview_height == 0.0f) return;
 
  const float inv_width = 1.f / preview_width;
  const float inv_height = 1.f / preview_height;
  for(size_t i = 0; i < num_points; i++)
  {
    const size_t idx = i * 2;
    points[idx + 0] *= inv_width;
    points[idx + 1] *= inv_height;
  }
}
 
int dt_dev_is_current_image(dt_develop_t *dev, int32_t imgid)
{
  return (dev->image_storage.id == imgid) ? 1 : 0;
}
 
void dt_dev_modulegroups_switch_tab(dt_develop_t *dev, dt_iop_module_t *module)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(module)) return;
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_MODULEGROUPS_SET, module);
}
 
gboolean dt_dev_masks_manager_is_visible(dt_develop_t *dev)
{
  return dev && dev->proxy.masks.module && dev->proxy.masks.is_visible
         && dev->proxy.masks.is_visible(dev->proxy.masks.module);
}
 
void dt_dev_masks_list_change(dt_develop_t *dev)
{
  if(dev->proxy.masks.module && dev->proxy.masks.list_change)
    dev->proxy.masks.list_change(dev->proxy.masks.module);
}
void dt_dev_masks_list_update(dt_develop_t *dev)
{
  if(dev->proxy.masks.module && dev->proxy.masks.list_update)
    dev->proxy.masks.list_update(dev->proxy.masks.module);
}
void dt_dev_masks_list_remove(dt_develop_t *dev, int formid, int parentid)
{
  if(dev->proxy.masks.module && dev->proxy.masks.list_remove)
    dev->proxy.masks.list_remove(dev->proxy.masks.module, formid, parentid);
}
void dt_dev_masks_selection_change(dt_develop_t *dev, struct dt_iop_module_t *module,
                                   const int selectid, const int throw_event)
{
  if(dev->proxy.masks.module && dev->proxy.masks.selection_change)
    dev->proxy.masks.selection_change(dev->proxy.masks.module, module, selectid, throw_event);
}
 
void dt_dev_snapshot_request(dt_develop_t *dev, const char *filename)
{
  dev->proxy.snapshot.filename = filename;
  dev->proxy.snapshot.request = TRUE;
  dt_control_queue_redraw_center();
}
 
dt_iop_module_t *dt_dev_module_duplicate(dt_develop_t *dev, dt_iop_module_t *base)
{
  // we create the new module
  dt_iop_module_t *module = (dt_iop_module_t *)calloc(1, sizeof(dt_iop_module_t));
  if(dt_iop_load_module(module, base->so, base->dev)) return NULL;
  module->instance = base->instance;
 
  // we set the multi-instance priority and the iop order
  int pmax = 0;
  for(GList *modules = base->dev->iop; modules; modules = g_list_next(modules))
  {
    dt_iop_module_t *mod = (dt_iop_module_t *)modules->data;
    if(mod->instance == base->instance)
    {
      if(pmax < mod->multi_priority) pmax = mod->multi_priority;
    }
  }
  // create a unique multi-priority
  pmax += 1;
  dt_iop_update_multi_priority(module, pmax);
 
  // add this new module position into the iop-order-list
  dt_ioppr_insert_module_instance(dev, module);
 
  // since we do not rename the module we need to check that an old module does not have the same name. Indeed
  // the multi_priority
  // are always rebased to start from 0, to it may be the case that the same multi_name be generated when
  // duplicating a module.
  int pname = module->multi_priority;
  char mname[128];
 
  do
  {
    snprintf(mname, sizeof(mname), "%d", pname);
    gboolean dup = FALSE;
 
    for(GList *modules = base->dev->iop; modules; modules = g_list_next(modules))
    {
      dt_iop_module_t *mod = (dt_iop_module_t *)modules->data;
      if(mod->instance == base->instance)
      {
        if(strcmp(mname, mod->multi_name) == 0)
        {
          dup = TRUE;
          break;
        }
      }
    }
 
    if(dup)
      pname++;
    else
      break;
  } while(1);
 
  // the multi instance name
  g_strlcpy(module->multi_name, mname, sizeof(module->multi_name));
  // we insert this module into dev->iop
  base->dev->iop = g_list_insert_sorted(base->dev->iop, module, dt_sort_iop_by_order);
 
  // always place the new instance after the base one
  if(!dt_ioppr_move_iop_after(base->dev, module, base))
  {
    fprintf(stderr, "[dt_dev_module_duplicate] can't move new instance after the base one\n");
  }
 
  // that's all. rest of insertion is gui work !
  return module;
}
 
 
 
void dt_dev_module_remove(dt_develop_t *dev, dt_iop_module_t *module)
{
  // if(dt_gui_widgets_suppressed()) return;
  int del = 0;
 
  if(dev->gui_attached)
  {
    dt_pthread_rwlock_wrlock(&dev->history_mutex);
    dt_dev_history_undo_start_record_locked(dev);
 
    const int history_end = dt_dev_get_history_end_ext(dev);
    int removed_before_end = 0;
    int history_pos = 0;
    GList *elem = dev->history;
    while(!IS_NULL_PTR(elem))
    {
      GList *next = g_list_next(elem);
      dt_dev_history_item_t *hist = (dt_dev_history_item_t *)(elem->data);
 
      if(module == hist->module)
      {
        dt_print(DT_DEBUG_HISTORY, "[dt_module_remode] removing obsoleted history item: %s %s %p %p\n",
                 hist->op_name, hist->multi_name, module, hist->module);
        dt_dev_free_history_item(hist);
        dev->history = g_list_delete_link(dev->history, elem);
        if(history_pos < history_end) removed_before_end++;
        del = 1;
      }
      history_pos++;
      elem = next;
    }
 
    if(removed_before_end > 0)
      dt_dev_set_history_end_ext(dev, MAX(0, history_end - removed_before_end));
 
    dt_dev_history_undo_end_record_locked(dev);
    dt_pthread_rwlock_unlock(&dev->history_mutex);
    if(del) dt_dev_history_undo_invalidate_module(module);
  }
 
  // and we remove it from the list
  for(GList *modules = dev->iop; modules; modules = g_list_next(modules))
  {
    dt_iop_module_t *mod = (dt_iop_module_t *)modules->data;
    if(mod == module)
    {
      dev->iop = g_list_delete_link(dev->iop, modules);
      break;
    }
  }
}
 
typedef struct dt_dev_multishow_state_t
{
  GHashTable *instance_counts;
  GHashTable *modules_in_history;
  GHashTable *prev_visible;
  GHashTable *next_visible;
} dt_dev_multishow_state_t;
 
void _dev_module_update_multishow(dt_develop_t *dev, struct dt_iop_module_t *module,
                                  const dt_dev_multishow_state_t *state)
{
  const int nb_instances = GPOINTER_TO_INT(
      g_hash_table_lookup(state->instance_counts, GINT_TO_POINTER(module->instance)));
 
  dt_iop_module_t *mod_prev = (dt_iop_module_t *)g_hash_table_lookup(state->prev_visible, module);
  dt_iop_module_t *mod_next = (dt_iop_module_t *)g_hash_table_lookup(state->next_visible, module);
 
  const gboolean move_next = mod_next
                                 ? dt_ioppr_check_can_move_after_iop(dev->iop, module, mod_next)
                                 : -1.0;
  const gboolean move_prev = mod_prev
                                 ? dt_ioppr_check_can_move_before_iop(dev->iop, module, mod_prev)
                                 : -1.0;
 
  if(IS_NULL_PTR(module->gui)) return;   // headless module: no buttons to update
 
  module->gui->multi_show_new = !(module->flags() & IOP_FLAGS_ONE_INSTANCE);
  // Never allow deleting the base instance (multi_priority == 0) nor modules limited to one instance.
  module->gui->multi_show_close =
      (nb_instances > 1 && module->multi_priority > 0 && !(module->flags() & IOP_FLAGS_ONE_INSTANCE));
  if(!IS_NULL_PTR(mod_next))
    module->gui->multi_show_up = move_next;
  else
    module->gui->multi_show_up = 0;
  if(!IS_NULL_PTR(mod_prev))
    module->gui->multi_show_down = move_prev;
  else
    module->gui->multi_show_down = 0;
 
  // If it's an additional instance supposed to be added by an history item after
  // the current history_end cursor, conceptually it doesn't exist yet,
  // even though it's dangling there on the pipe. So hide it from GUI.
  if(nb_instances > 1
     && module->multi_priority > 0
     && !g_hash_table_contains(state->modules_in_history, module))
    gtk_widget_hide(module->gui->expander);
}
 
// FIXME: this function should just disappear, as it mixes concepts from multi-instances from before
// pipeline reordering and pipeline reordering. 
// Multi-instances concept should just be ditched entirely.
void dt_dev_modules_update_multishow(dt_develop_t *dev)
{
  dt_ioppr_check_iop_order(dev, 0, "dt_dev_modules_update_multishow");
  const int history_end = dt_dev_get_history_end_ext(dev);
 
  dt_dev_multishow_state_t state = { 0 };
  state.instance_counts = g_hash_table_new(g_direct_hash, g_direct_equal);
  state.modules_in_history = g_hash_table_new(g_direct_hash, g_direct_equal);
  state.prev_visible = g_hash_table_new(g_direct_hash, g_direct_equal);
  state.next_visible = g_hash_table_new(g_direct_hash, g_direct_equal);
 
  // Precompute how many instances exist for each base module.
  for(GList *modules = dev->iop; modules; modules = g_list_next(modules))
  {
    const dt_iop_module_t *mod = (dt_iop_module_t *)modules->data;
    gpointer key = GINT_TO_POINTER(mod->instance);
    int count = GPOINTER_TO_INT(g_hash_table_lookup(state.instance_counts, key));
    g_hash_table_replace(state.instance_counts, key, GINT_TO_POINTER(count + 1));
  }
 
  // Precompute which modules exist in history up to history_end.
  int history_pos = 0;
  for(GList *history = g_list_first(dev->history);
      history && history_pos < history_end;
      history = g_list_next(history), history_pos++)
  {
    dt_dev_history_item_t *hist = (dt_dev_history_item_t *)history->data;
    if(hist->module) g_hash_table_add(state.modules_in_history, hist->module);
  }
 
  // Precompute previous visible module in pipeline order.
  dt_iop_module_t *last_visible = NULL;
  for(GList *modules = g_list_first(dev->iop); modules; modules = g_list_next(modules))
  {
    dt_iop_module_t *mod = (dt_iop_module_t *)modules->data;
    if(dt_iop_gui_module_is_visible(mod))
    {
      g_hash_table_insert(state.prev_visible, mod, last_visible);
      last_visible = mod;
    }
  }
 
  // Precompute next visible module in GUI order (reverse pipeline).
  last_visible = NULL;
  for(GList *modules = g_list_last(dev->iop); modules; modules = g_list_previous(modules))
  {
    dt_iop_module_t *mod = (dt_iop_module_t *)modules->data;
    if(dt_iop_gui_module_is_visible(mod))
    {
      g_hash_table_insert(state.next_visible, mod, last_visible);
      last_visible = mod;
    }
  }
 
  for(GList *modules = dev->iop; modules; modules = g_list_next(modules))
  {
    dt_iop_module_t *mod = (dt_iop_module_t *)modules->data;
 
    if(dt_iop_gui_module_is_visible(mod))
      _dev_module_update_multishow(dev, mod, &state);
  }
 
  g_hash_table_destroy(state.instance_counts);
  g_hash_table_destroy(state.modules_in_history);
  g_hash_table_destroy(state.prev_visible);
  g_hash_table_destroy(state.next_visible);
}
 
gchar *dt_history_item_get_label(const struct dt_iop_module_t *module)
{
  gchar *label;
  /* create a history button and add to box */
  if(!module->multi_name[0] || strcmp(module->multi_name, "0") == 0)
    label = g_strdup(module->name());
  else
  {
    // multi_name is free-typed user text (dt_iop_gui_rename_module()), but this label is
    // rendered through gtk_label_set_markup_with_mnemonic() so that module->name()'s own
    // mnemonic keeps working. Escape it for markup and double its underscores so it prints
    // literally instead of breaking markup parsing ("&") or being eaten as a mnemonic ("_").
    gchar *escaped_multi_name = g_markup_escape_text(module->multi_name, -1);
    gchar **underscore_parts = g_strsplit(escaped_multi_name, "_", -1);
    gchar *safe_multi_name = g_strjoinv("__", underscore_parts);
    g_strfreev(underscore_parts);
    dt_free(escaped_multi_name);
 
    label = g_strdup_printf("%s %s", module->name(), safe_multi_name);
    dt_free(safe_multi_name);
  }
  return label;
}
 
gchar *dt_dev_get_multi_name(const struct dt_iop_module_t *module)
{
  gboolean has_multi_name = g_strcmp0(module->multi_name, "0") != 0 && g_strcmp0(module->multi_name, "") != 0;
  gchar *label = has_multi_name ? g_strdup(module->multi_name) : g_strdup("");
 
  return label;
}
 
gchar *dt_history_item_get_name(const struct dt_iop_module_t *module)
{
  gchar *label;
  /* create a history button and add to box */
  if(!module->multi_name[0] || strcmp(module->multi_name, "0") == 0)
    label = delete_underscore(module->name());
  else
  {
    gchar *clean_name = delete_underscore(module->name());
    label = g_strdup_printf("%s %s", clean_name, module->multi_name);
    dt_free(clean_name);
  }
  dt_capitalize_label(label);
  return label;
}
 
gchar *dt_history_item_get_name_html(const struct dt_iop_module_t *module)
{
  gchar *clean_name = delete_underscore(module->name());
  gchar *label;
  /* create a history button and add to box */
  if(!module->multi_name[0] || strcmp(module->multi_name, "0") == 0)
    label = g_markup_escape_text(clean_name, -1);
  else
    label = g_markup_printf_escaped("%s <span size=\"smaller\">%s</span>", clean_name, module->multi_name);
  dt_free(clean_name);
  return label;
}
 
static int dt_dev_distort_backtransform_locked(const dt_dev_pixelpipe_t *pipe, const double iop_order,
                                               const int transf_direction, float *points, size_t points_count);
 
/* These two are the whole of the mask GUI's coordinate handling -- every shape's centre, every
 * handle, every source position routes through one of them -- and they ask the geometry service
 * the simplest question there is: everything, in order, no bound.
 */
 
int dt_dev_distort_transform_gui(dt_develop_t *dev, const double iop_order, const int transf_direction,
                                 float *points, size_t points_count)
{
  if(IS_NULL_PTR(dev)) return 0;
  return dt_geometry_transform(dev, iop_order, transf_direction, points, points_count);
}
 
int dt_dev_distort_backtransform_gui(dt_develop_t *dev, const double iop_order, const int transf_direction,
                                     float *points, size_t points_count)
{
  if(IS_NULL_PTR(dev)) return 0;
  return dt_geometry_backtransform(dev, iop_order, transf_direction, points, points_count);
}
 
gboolean dt_dev_processed_size_gui(dt_develop_t *dev, int *width, int *height)
{
  if(IS_NULL_PTR(dev)) return FALSE;
 
  int w = 0;
  int h = 0;
  if(dt_geometry_chain_processed_size(dev->geometry_chain, &w, &h)
     && dt_geometry_chain_authoritative(dev->geometry_chain) && w > 0 && h > 0)
  {
    if(!IS_NULL_PTR(width)) *width = w;
    if(!IS_NULL_PTR(height)) *height = h;
    return TRUE;
  }
 
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  if(geometry.processed_width <= 0 || geometry.processed_height <= 0) return FALSE;
  if(!IS_NULL_PTR(width)) *width = geometry.processed_width;
  if(!IS_NULL_PTR(height)) *height = geometry.processed_height;
  return TRUE;
}
 
gboolean dt_dev_module_geometry_gui(dt_develop_t *dev, dt_iop_module_t *module, dt_iop_roi_t *in,
                                    dt_iop_roi_t *out)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(module)) return FALSE;
 
  const dt_geometry_record_t *const record
      = dt_geometry_chain_find(dev->geometry_chain, module->op, module->multi_priority);
  if(IS_NULL_PTR(record) || !dt_geometry_chain_authoritative(dev->geometry_chain)) return FALSE;
 
  if(!IS_NULL_PTR(in)) *in = record->in;
  if(!IS_NULL_PTR(out)) *out = record->out;
  return TRUE;
}
 
int dt_dev_coordinates_raw_abs_to_image_abs(dt_develop_t *dev, float *points, size_t points_count)
{
  return dt_geometry_transform(dev, 0.0, DT_DEV_TRANSFORM_DIR_ALL, points, points_count);
}
 
int dt_dev_coordinates_image_abs_to_raw_abs(dt_develop_t *dev, float *points, size_t points_count)
{
  return dt_geometry_backtransform(dev, 0.0, DT_DEV_TRANSFORM_DIR_ALL, points, points_count);
}
 
// only call directly or indirectly from dt_dev_distort_transform_plus, so that it runs with the history locked
int dt_dev_distort_transform_locked(const dt_dev_pixelpipe_t *pipe, const double iop_order,
                                    const int transf_direction, float *points, size_t points_count)
{
  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);
    dt_iop_module_t *module = piece->module;
    if(piece->enabled
       && ((transf_direction == DT_DEV_TRANSFORM_DIR_ALL)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_FORW_INCL && module->iop_order >= iop_order)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_FORW_EXCL && module->iop_order > iop_order)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_BACK_INCL && module->iop_order <= iop_order)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_BACK_EXCL && module->iop_order < iop_order))
       && !dt_dev_pixelpipe_activemodule_disables_currentmodule(pipe->dev, module))
    {
      module->distort_transform(module, pipe, piece, points, points_count);
    }
  }
  return 1;
}
 
int dt_dev_distort_transform_plus(const dt_dev_pixelpipe_t *pipe, const double iop_order, const int transf_direction,
                                  float *points, size_t points_count)
{
  dt_dev_distort_transform_locked(pipe, iop_order, transf_direction, points, points_count);
  return 1;
}
 
// Internal backtransform loop. Keep this file-local so callers use the public wrappers.
static int dt_dev_distort_backtransform_locked(const dt_dev_pixelpipe_t *pipe, const double iop_order,
                                               const int transf_direction, float *points, size_t points_count)
{
  for(GList *pieces = g_list_last(pipe->nodes); pieces; pieces = g_list_previous(pieces))
  {
    dt_dev_pixelpipe_iop_t *piece = (dt_dev_pixelpipe_iop_t *)(pieces->data);
    dt_iop_module_t *module = piece->module;
    if(piece->enabled
       && ((transf_direction == DT_DEV_TRANSFORM_DIR_ALL)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_FORW_INCL && module->iop_order >= iop_order)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_FORW_EXCL && module->iop_order > iop_order)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_BACK_INCL && module->iop_order <= iop_order)
           || (transf_direction == DT_DEV_TRANSFORM_DIR_BACK_EXCL && module->iop_order < iop_order))
       && !dt_dev_pixelpipe_activemodule_disables_currentmodule(pipe->dev, module))
    {
      module->distort_backtransform(module, pipe, piece, points, points_count);
    }
  }
  return 1;
}
 
int dt_dev_distort_backtransform_plus(const dt_dev_pixelpipe_t *pipe, const double iop_order, const int transf_direction,
                                      float *points, size_t points_count)
{
  const int success = dt_dev_distort_backtransform_locked(pipe, iop_order, transf_direction, points, points_count);
  return success;
}
 
dt_dev_pixelpipe_iop_t *dt_dev_distort_get_iop_pipe(struct dt_dev_pixelpipe_t *pipe,
                                                    struct dt_iop_module_t *module)
{
  for(const GList *pieces = g_list_last(pipe->nodes); pieces; pieces = g_list_previous(pieces))
  {
    dt_dev_pixelpipe_iop_t *piece = (dt_dev_pixelpipe_iop_t *)(pieces->data);
    if(piece->module == module)
    {
      return piece;
    }
  }
  return NULL;
}
 
// set the module list order
void dt_dev_signal_modules_moved(dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev)) return;
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_MODULE_MOVED);
}
 
void dt_dev_undo_start_record(dt_develop_t *dev)
{
  const dt_view_t *cv = dt_view_manager_get_current_view(dt_view_manager_get_global());
 
  /* record current history state : before change (needed for undo) */
  if(dev->gui_attached && cv->view((dt_view_t *)cv) == DT_VIEW_DARKROOM)
  {
    dt_dev_history_undo_start_record(dev);
  }
}
 
void dt_dev_undo_end_record(dt_develop_t *dev)
{
  const dt_view_t *cv = dt_view_manager_get_current_view(dt_view_manager_get_global());
 
  /* record current history state : after change (needed for undo) */
  if(dev->gui_attached && cv->view((dt_view_t *)cv) == DT_VIEW_DARKROOM)
  {
    dt_dev_history_undo_end_record(dev);
    DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_HISTORY_CHANGE);
  }
}
 
gboolean dt_masks_get_lock_mode(dt_develop_t *dev)
{
  if(dev->gui_attached)
  {
    dt_pthread_mutex_lock(&dt_gui_get_global()->mutex);
    const gboolean state = dev->mask_lock;
    dt_pthread_mutex_unlock(&dt_gui_get_global()->mutex);
    return state;
  }
  return FALSE;
}
 
void dt_masks_set_lock_mode(dt_develop_t *dev, gboolean mode)
{
  if(dev->gui_attached)
  {
    dt_pthread_mutex_lock(&dt_gui_get_global()->mutex);
    dev->mask_lock = mode;
    dt_pthread_mutex_unlock(&dt_gui_get_global()->mutex);
  }
}
 
int32_t dt_dev_get_history_end_ext(dt_develop_t *dev)
{
  const int num_items = g_list_length(dev->history);
  return CLAMP(dev->history_end, 0, num_items);
}
 
void dt_dev_set_history_end_ext(dt_develop_t *dev, const uint32_t index)
{
  const int num_items = g_list_length(dev->history);
  dev->history_end = CLAMP(index, 0, num_items);
  dt_dev_set_history_hash(dev, dt_dev_history_compute_hash(dev));
}
 
void dt_dev_append_changed_tag(const int32_t imgid)
{
  /* attach changed tag reflecting actual change */
  guint tagid = 0;
  dt_tag_new("darktable|changed", &tagid);
  const gboolean tag_change = dt_tag_attach(tagid, imgid, FALSE, FALSE);
  if(tag_change) DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_TAG_CHANGED);
}
 
void dt_dev_masks_update_hash(dt_develop_t *dev)
{
  // dev->forms is protected by masks_mutex, not history_mutex -- this only reads the
  // forms list, so it must not be wrapped in a history_mutex lock by callers (that would
  // needlessly exclude the pipeline thread's history reads while this walk runs).
  dt_pthread_rwlock_rdlock(&dev->masks_mutex);
 
  uint64_t hash = 5381;
  for(GList *form = g_list_first(dev->forms); form; form = g_list_next(form))
  {
    dt_masks_form_t *shape = (dt_masks_form_t *)form->data;
    hash = dt_masks_form_get_own_hash(hash, dev->forms, shape);
  }
 
  dt_pthread_rwlock_unlock(&dev->masks_mutex);
 
  // Keep on accumulating "changed" states until something saves the new stack
  // and resets that to 0
  uint64_t old_hash = dev->forms_hash;
  dev->forms_changed |= (old_hash != hash);
  dev->forms_hash = hash;
}
 
float dt_dev_get_natural_scale(dt_develop_t *dev)
{
  if(!dt_dev_viewport_configured(dev) || !dt_dev_geometry_raw_inited(dev)) return -1.f;
 
  return fminf(fminf((float)dt_dev_viewport_box_width(dev) / (float)dt_dev_geometry_processed_width(dev),
                      (float)dt_dev_viewport_box_height(dev) / (float)dt_dev_geometry_processed_height(dev)),
                1.f);
}
 
float dt_dev_get_fit_scale(dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev)) return 1.0f;
  return dt_dev_viewport_scaling(dev) / dt_gui_get_global()->ppd;
}
 
float dt_dev_get_overlay_scale(dt_develop_t *dev)
{
  return dt_dev_get_fit_scale(dev);
}
 
float dt_dev_get_widget_zoom_scale(const dt_develop_t *dev, const float scaling)
{
  if(IS_NULL_PTR(dev)) return 1.0f;
  return scaling * dt_dev_roi_request_natural_scale(dev) / dt_gui_get_global()->ppd;
}
 
void dt_dev_get_widget_center(const dt_develop_t *dev, float *point)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(point)) return;
  point[0] = 0.5f * dt_dev_viewport_widget_width(dev);
  point[1] = 0.5f * dt_dev_viewport_widget_height(dev);
}
 
void dt_dev_get_image_box_in_widget(const dt_develop_t *dev, const int32_t width, const int32_t height, float *box)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(box)) return;
 
  const float scale = dt_dev_viewport_scaling(dev) / dt_gui_get_global()->ppd;
  const float roi_width = fminf(width, dt_dev_roi_request_preview_width(dev) * scale);
  const float roi_height = fminf(height, dt_dev_roi_request_preview_height(dev) * scale);
  const float border = dt_dev_viewport_border_size(dev);
 
  box[0] = fmaxf(border, 0.5f * (width - roi_width));
  box[1] = fmaxf(border, 0.5f * (height - roi_height));
  box[2] = fminf(width - 2 * border, roi_width);
  box[3] = fminf(height - 2 * border, roi_height);
}
 
float dt_dev_get_zoom_level(const dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev)) return 1.f;
  return dt_dev_viewport_scaling(dev) * dt_dev_roi_request_natural_scale(dev);
}
 
void dt_dev_reset_roi(dt_develop_t *dev)
{
  // Zoom and pan back to "fit". The ROI request is derived from the viewport, so the reset
  // republishes it; there is nothing to invalidate by hand, and an invalidation here could not
  // have survived that republication anyway.
  dt_dev_viewport_reset(dev);
}
 
void dt_dev_convert_roi(const dt_develop_t *dev, const dt_iop_roi_t *roi_in, dt_iop_roi_t *roi_out,
                        const dt_dev_roi_space_t from, const dt_dev_roi_space_t to)
{
  if(IS_NULL_PTR(dev) || IS_NULL_PTR(roi_in) || IS_NULL_PTR(roi_out)) return;
 
  *roi_out = *roi_in;
  if(from == to) return;
 
  const float factor = (from == DT_DEV_ROI_GUI_LOGICAL && to == DT_DEV_ROI_PIPELINE)
                           ? dt_gui_get_global()->ppd
                           : 1.0f / dt_gui_get_global()->ppd;
 
  // x/y/width/height belong to the GUI/pipeline geometry boundary and therefore
  // follow the ppd factor. roi->scale stays unchanged because it expresses the
  // image-space sampling ratio, which must not depend on GUI density.
  roi_out->x = lroundf(roi_in->x * factor);
  roi_out->y = lroundf(roi_in->y * factor);
  roi_out->width = lroundf(roi_in->width * factor);
  roi_out->height = lroundf(roi_in->height * factor);
  roi_out->scale = roi_in->scale * factor;
}
 
gboolean dt_dev_clip_roi(dt_develop_t *dev, cairo_t *cr, int32_t width, int32_t height)
{
  // DO NOT MODIFIY !! //
 
  const float wd = dt_dev_roi_request_preview_width(dev);
  const float ht = dt_dev_roi_request_preview_height(dev);
  if(wd == 0.f || ht == 0.f) return TRUE;
 
  const float zoom_scale = dt_dev_get_overlay_scale(dev);
  const int32_t border = dt_dev_viewport_border_size(dev);
  const float roi_width = fminf(width, wd * zoom_scale);
  const float roi_height = fminf(height, ht * zoom_scale);
 
  const float rec_x = fmaxf(border, (width - roi_width) * 0.5f);
  const float rec_y = fmaxf(border, (height - roi_height) * 0.5f);
  const float rec_w = fminf(width - 2 * border, roi_width);
  const float rec_h = fminf(height - 2 * border, roi_height);
 
  cairo_rectangle(cr, rec_x, rec_y, rec_w, rec_h);
  cairo_clip(cr);
 
  return FALSE;
}
 
static gboolean _dev_translate_roi(dt_develop_t *dev, cairo_t *cr, int32_t width, int32_t height)
{
  // DO NOT MODIFIY !! //
  // used by preview image scalling, guide and modules //
  int proc_wd = 0;
  int proc_ht = 0;
  dt_dev_get_processed_size(dev, &proc_wd, &proc_ht);
  if(proc_wd == 0.f || proc_ht == 0.f) return TRUE;
 
  // Get image's origin position and scale
  const float zoom_scale = dt_dev_get_zoom_level(dev) / dt_gui_get_global()->ppd;
  const float tx = 0.5f * width - dt_dev_viewport_center_x(dev) * proc_wd * zoom_scale;
  const float ty = 0.5f * height - dt_dev_viewport_center_y(dev) * proc_ht * zoom_scale;
 
  cairo_translate(cr, tx, ty);
  
  return FALSE;
}
 
gboolean dt_dev_rescale_roi(dt_develop_t *dev, cairo_t *cr, int32_t width, int32_t height)
{
  if(_dev_translate_roi(dev, cr, width, height))
    return TRUE;
  const float scale = dt_dev_get_fit_scale(dev);
  cairo_scale(cr, scale, scale);
  
  return FALSE;
}
 
gboolean dt_dev_rescale_roi_to_input(dt_develop_t *dev, cairo_t *cr, int32_t width, int32_t height)
{
  if(_dev_translate_roi(dev, cr, width, height))
    return TRUE;
  const float scale = dt_dev_get_zoom_level(dev) / dt_gui_get_global()->ppd;
  cairo_scale(cr, scale, scale);
  
  return FALSE;
}
 
gboolean dt_dev_check_zoom_scale_bounds(dt_develop_t *dev)
{
  const float natural_scale = dt_dev_roi_request_natural_scale(dev);
  const float scaling = dt_dev_viewport_scaling(dev);
 
  // Limit zoom in to 16x the size of an apparent pixel on screen
  const float pixel_actual_size = natural_scale * scaling;
  const float pixel_max_size = 16.f;
 
  if(pixel_actual_size >= pixel_max_size)
  {
    // Restore old scaling (caller should handle this)
    dt_dev_viewport_set_scaling(dev, pixel_max_size / natural_scale);
    return TRUE;
  }
 
  // Limit zoom out to 1/3rd of the fit-to-window size
  const float min_scaling = 0.33f;
  if(scaling < min_scaling)
  {
    dt_dev_viewport_set_scaling(dev, min_scaling);
    return TRUE;
  }
  return FALSE;
}
 
void dt_dev_update_mouse_effect_radius(dt_develop_t *dev)
{
  float zoom_level = dt_dev_get_zoom_level(dev);
  if(zoom_level <= 0.f) zoom_level = 1.0f;
 
  // Keep mouse hit-tests usable across zoom levels by bounding the selection
  // radius once it is expressed in image-space pixels.
  const float radius = dt_widget_mouse_radius();
  const float clamped = CLAMP(radius, DT_PIXEL_APPLY_DPI(4.0f) / zoom_level,
                              DT_PIXEL_APPLY_DPI(15.0f) / zoom_level);
  dt_widget_set_mouse_radius(radius, clamped);
 
  dt_print(DT_DEBUG_MASKS,
           "[mouse] effect_radius=%0.3f effect_radius_clamped=%0.3f zoom_level=%0.4f ppd=%0.4f\n",
           radius, clamped, zoom_level, dt_screen_ppd());
}
 
void dt_dev_backbuf_take_keepalive(dt_backbuf_t *backbuf, struct dt_pixel_cache_entry_t *entry)
{
  if(IS_NULL_PTR(backbuf)) return;
  /* Idempotent: a republication resolving to the same cacheline must not stack references, and
   * must not drop the one it holds either -- which an unconditional release-then-take would do
   * for a moment, long enough for the LRU to take the entry the screen is showing. */
  if(backbuf->keepalive == entry) return;
 
  dt_dev_backbuf_release_keepalive(backbuf);
  if(!IS_NULL_PTR(entry))
  {
    dt_dev_pixelpipe_cache_ref_count_entry(TRUE, entry);
    backbuf->keepalive = entry;
  }
}
 
void dt_dev_backbuf_release_keepalive(dt_backbuf_t *backbuf)
{
  if(IS_NULL_PTR(backbuf) || IS_NULL_PTR(backbuf->keepalive)) return;
  /* By POINTER. This reference was taken by pointer, and an entry's hash is not stable under
   * rekey reuse -- see dt_dev_pixelpipe_cache_unref_entry() for what releasing by hash costs. */
  dt_dev_pixelpipe_cache_unref_entry(backbuf->keepalive);
  backbuf->keepalive = NULL;
}
 
void dt_dev_set_backbuf(dt_backbuf_t *backbuf, const int width, const int height, const size_t bpp, 
                        const int64_t hash, const int64_t history_hash)
{
  /* One publication: the shape and the cacheline it describes settle together, so no consumer
   * can pair a hash with dimensions from a different frame. The atomics are written directly
   * rather than through the single-field setters, which bracket the counter themselves. */
  dt_dev_backbuf_publish_begin(backbuf);
  backbuf->height = height;
  backbuf->width = width;
  backbuf->bpp = bpp;
  dt_atomic_set_uint64(&backbuf->hash, (uint64_t)hash);
  dt_atomic_set_uint64(&backbuf->history_hash, (uint64_t)history_hash);
  dt_dev_backbuf_publish_end(backbuf);
}
 
// 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