dev_roi_request.c

Go to the documentation of this file.

/*
    This file is part of Ansel.
    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 "develop/dev_roi_request.h"
#include "common/conf.h"
#include "develop/dev_geometry.h"
#include "develop/dev_viewport.h"
#include "develop/develop.h"
#include "develop/pixelpipe_hb.h"
 
#include <string.h>
 
/* Same publication protocol as the geometry record and the viewport: one writer (the GUI
 * thread), a generation that is odd mid-publication, readers that copy and retry.
 */
 
static inline gboolean _payload_equal(const dt_dev_roi_request_t *a, const dt_dev_roi_request_t *b)
{
  return a->box_width == b->box_width
         && a->box_height == b->box_height
         && a->processed_width == b->processed_width
         && a->processed_height == b->processed_height
         && a->preview_width == b->preview_width
         && a->preview_height == b->preview_height
         && a->natural_scale == b->natural_scale
         && a->scaling == b->scaling
         && a->center_x == b->center_x
         && a->center_y == b->center_y
         && a->valid == b->valid;
}
 
dt_dev_roi_request_t dt_dev_roi_request_neutral(void)
{
  dt_dev_roi_request_t request;
  memset(&request, 0, sizeof(request));
  request.natural_scale = -1.f;
  request.scaling = 1.f;
  request.center_x = 0.5f;
  request.center_y = 0.5f;
  return request;
}
 
void dt_dev_roi_request_init(dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev)) return;
 
  dev->roi_request.value = dt_dev_roi_request_neutral();
  dt_atomic_set_uint64(&dev->roi_request.generation, 0);
}
 
dt_dev_roi_request_t dt_dev_roi_request_get(const dt_develop_t *dev)
{
  dt_dev_roi_request_t request;
  memset(&request, 0, sizeof(request));
  if(IS_NULL_PTR(dev)) return request;
 
  const dt_dev_roi_request_store_t *store = &dev->roi_request;
 
  for(;;)
  {
    const uint64_t before = dt_atomic_get_uint64(&store->generation);
    if(before & 1) continue;
 
    request = store->value;
 
    const uint64_t after = dt_atomic_get_uint64(&store->generation);
    if(before == after) break;
  }
 
  return request;
}
 
uint64_t dt_dev_roi_request_publish(dt_develop_t *dev)
{
  if(IS_NULL_PTR(dev)) return 0;
 
  // One coherent read of each input, so the request cannot mix two viewport states or two
  // geometries -- the whole point of publishing them as records in the first place.
  const dt_dev_viewport_state_t viewport = dt_dev_viewport_get(dev);
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
 
  dt_dev_roi_request_t next = dev->roi_request.value;
 
  next.box_width = viewport.box_width;
  next.box_height = viewport.box_height;
  next.scaling = viewport.scaling;
  next.center_x = viewport.center_x;
  next.center_y = viewport.center_y;
  next.processed_width = geometry.processed_width;
  next.processed_height = geometry.processed_height;
 
  // dt_dev_get_natural_scale()'s guard, reproduced: no viewport allocation or no raw geometry
  // means there is nothing to fit the image into, and -1 is the sentinel every consumer of the
  // product already handles.
  next.natural_scale = (viewport.configured && geometry.raw_inited)
                           ? dt_dev_roi_natural_scale(viewport.box_width, viewport.box_height,
                                                      geometry.processed_width, geometry.processed_height)
                           : -1.f;
 
  // roundf(), NOT a truncation: these must match the ROI the worker requests, which rounds too.
  // A truncation here disagreed by 1px whenever the fraction was >= 0.5, which is image-dependent,
  // and silently broke dt_dev_pixelpipe_has_preview_output() -- hence ashift structure detection
  // and drawing -- on some images but not others.
  next.preview_width = roundf(next.natural_scale * next.processed_width);
  next.preview_height = roundf(next.natural_scale * next.processed_height);
 
  // DERIVED, never asserted. This used to be an unconditional TRUE, which made the record claim
  // it was usable from dt_dev_init() onwards -- before any viewport, any image, any pipe -- and
  // made dt_dev_reset_roi()'s invalidation unobservable, since the viewport reset republishes on
  // the very next line.
  //
  // Each of these three flags is FALSE only while its own numbers are still zero: box_* is
  // written only by dt_dev_viewport_set_box(), which sets `configured' in the same publication;
  // raw_* only by _dt_dev_mipmap_prefetch_full(), which pairs a FALSE with 0x0; processed_* only
  // by dt_dev_geometry_set_processed_size(), which always sets its flag. So a FALSE here always
  // travels with a zero, which is what keeps _darkroom_pipeline_inputs_ready() (it tests the
  // numbers, not the flags) rejecting exactly the states this reports as unusable -- the worker
  // naps and retries instead of reaching _update_darkroom_roi(), whose !valid branch returns
  // without writing its out-params and would leave the caller planning a 0x0 ROI.
  //
  // Do not clear one of these flags without zeroing its numbers, and do not gate this on
  // anything a publication cannot re-derive.
  next.valid = viewport.configured && geometry.raw_inited && geometry.processed_inited;
 
  // Advance the generation only on a real change, so a consumer can use it as a cache key
  // without being invalidated by every republication of identical numbers.
  const uint64_t published = dt_atomic_get_uint64(&dev->roi_request.generation);
  if(_payload_equal(&dev->roi_request.value, &next)) return published;
 
  /* Drawn-mask rasterisation step, decided HERE because this is the GUI thread and the only
   * place that knows both scales: the main pipe renders at natural_scale * scaling (the zoom
   * the user set) and the preview at natural_scale (always fit). It must not be decided in the
   * pipeline thread -- that would read a user preference and a viewport from a thread that owns
   * neither, and would recompute per frame what changes only when the viewport does.
   *
   * "never" pins both to 1. Absent a GUI, nothing calls this at all, so the pipes keep the
   * pixel-accurate step their init gave them. */
  int main_step = 1;
  int preview_step = 1;
  if(dev->gui_attached && next.valid && next.natural_scale > 0.f)
  {
    /* The preference governs the MAIN pipe only. The preview is always rendered at fit size and
     * is never what the user inspects for pixel accuracy, so its step follows its own ROI
     * unconditionally. */
    gchar *mode = dt_conf_get_string("plugins/darkroom/masks/rasterization");
    const gboolean fast = IS_NULL_PTR(mode) || strcmp(mode, "never") != 0;
    g_free(mode);
 
    const float main_scale = next.natural_scale * next.scaling;
    if(fast && main_scale > 0.f) main_step = (int)floorf(1.f / main_scale);
    preview_step = (int)floorf(1.f / next.natural_scale);
  }
  dt_dev_pixelpipe_set_mask_rasterization_step(dev->pipe, main_step);
  dt_dev_pixelpipe_set_mask_rasterization_step(dev->preview_pipe, preview_step);
 
  /* Which pipes' PLANS does this change invalidate? Decided from the old payload while we still
   * hold it. The preview plans from (natural_scale, processed, box) only -- _update_darkroom_roi()
   * ignores scaling and centre for it -- so a zoom or pan tick must not cost a preview run. The
   * main pipe plans from all of it. `valid' flipping is a plan change for both: the first usable
   * record is what lets a pipe plan at all. */
  const dt_dev_roi_request_t previous = dev->roi_request.value;
  const gboolean preview_plan_changed = previous.processed_width != next.processed_width
                                        || previous.processed_height != next.processed_height
                                        || previous.box_width != next.box_width
                                        || previous.box_height != next.box_height
                                        || previous.natural_scale != next.natural_scale
                                        || previous.valid != next.valid;
 
  next.generation = published + 2;   // stays even: the store's counter is the odd/even flag
  dt_atomic_set_uint64(&dev->roi_request.generation, published + 1);
  dev->roi_request.value = next;
  dt_atomic_set_uint64(&dev->roi_request.generation, published + 2);
 
  /* A record nobody replans from is a lie waiting to be displayed. This is the fix for #1157:
   * the darkroom worker latches this record ONCE per iteration, and its history resync loop
   * spans 100-400 ms -- so a history commit whose SYNCH flag lands inside that loop gets its
   * flag consumed by a run still planned from the PREVIOUS latch. The killswitch raised with
   * the flag does not save that run either: the worker resets it when processing starts. The
   * run then renders the new history into the old geometry -- the border-clamped smear of
   * issue #1157 -- publishes it, and, since this function used to flag nothing, NOTHING forced
   * a corrective render: the frame was terminal until the user zoomed.
   *
   * So the publisher re-arms the pipes itself, which also makes the viewport setters' callers'
   * manual flagging (dt_dev_pixelpipe_change_zoom_main, dt_dev_configure_real) a guarantee
   * instead of a convention.
   *
   * ORDER MATTERS: the flags are raised AFTER the seqlock store above completes. A worker woken
   * by the flag re-latches, and must not be able to re-latch the old record -- flag observed
   * implies store visible. Raising them before the store would recreate the bug one level down.
   *
   * The shutdown is the same killswitch _change_pipe() raises: an in-flight run planned from
   * the previous record is superseded and should stop wasting the device. */
  if(dev->gui_attached)
  {
    if(preview_plan_changed && !IS_NULL_PTR(dev->preview_pipe))
    {
      dt_dev_pixelpipe_or_changed(dev->preview_pipe, DT_DEV_PIPE_ZOOMED);
      dt_atomic_set_int(&dev->preview_pipe->shutdown, TRUE);
    }
    /* Any payload change alters the main plan: _payload_equal() already returned FALSE, and
     * every field it compares is either a main-plan input or derived from one. */
    if(!IS_NULL_PTR(dev->pipe))
    {
      dt_dev_pixelpipe_or_changed(dev->pipe, DT_DEV_PIPE_ZOOMED);
      dt_atomic_set_int(&dev->pipe->shutdown, TRUE);
    }
  }
 
  return next.generation;
}
 
void dt_dev_roi_request_latch(dt_dev_pixelpipe_t *pipe, const dt_dev_roi_request_t *request)
{
  if(IS_NULL_PTR(pipe) || IS_NULL_PTR(request)) return;
 
  const uint64_t published = dt_atomic_get_uint64(&pipe->roi_request.generation);
  dt_atomic_set_uint64(&pipe->roi_request.generation, published + 1);
  pipe->roi_request.value = *request;
  dt_atomic_set_uint64(&pipe->roi_request.generation, published + 2);
}
 
dt_dev_roi_request_t dt_dev_roi_request_of_pipe(const dt_dev_pixelpipe_t *pipe)
{
  dt_dev_roi_request_t request = dt_dev_roi_request_neutral();
  if(IS_NULL_PTR(pipe)) return request;
 
  for(;;)
  {
    const uint64_t before = dt_atomic_get_uint64(&pipe->roi_request.generation);
    if(before & 1) continue;
 
    request = pipe->roi_request.value;
 
    const uint64_t after = dt_atomic_get_uint64(&pipe->roi_request.generation);
    if(before == after) break;
  }
 
  return request;
}
 
int32_t dt_dev_roi_request_preview_width(const dt_develop_t *dev)
{
  return dt_dev_roi_request_get(dev).preview_width;
}
 
int32_t dt_dev_roi_request_preview_height(const dt_develop_t *dev)
{
  return dt_dev_roi_request_get(dev).preview_height;
}
 
float dt_dev_roi_request_natural_scale(const dt_develop_t *dev)
{
  return dt_dev_roi_request_get(dev).natural_scale;
}
 
gboolean dt_dev_roi_request_valid(const dt_develop_t *dev)
{
  return dt_dev_roi_request_get(dev).valid;
}
 
// 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