worker.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    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/>.
*/
 
/*
 * drawlayer realtime worker subsystem
 *
 * Realtime painting now advances in heartbeat batches:
 * - read current layer content from the authoritative full-resolution
 *   `base_patch`,
 * - rasterize a small dab batch into a worker-private scratch patch,
 * - copy only the damaged area back into `base_patch`,
 * - publish one regular pipeline refresh before continuing.
 *
 * This keeps base-patch ownership authoritative while avoiding long stretches
 * where rasterization and pipeline refresh starve each other.
 */
 
#include "iop/drawlayer/worker.h"
 
#include "iop/drawlayer/cache.h"      // dt_drawlayer_cache_patch_t, ..._wrlock()
#include "iop/drawlayer/common.h"     // dt_drawlayer_commit_dabs(), ..._build_worker_input_dab()
#include "iop/drawlayer/module.h"     // dt_iop_drawlayer_data_t
#include "iop/drawlayer/runtime.h"    // dt_iop_drawlayer_gui_data_t
 
#include "control/user_message.h"    // dt_control_log()
#include "control/redraw.h"           // dt_control_queue_redraw_center()
#include "develop/develop.h"          // dt_develop_t
#include "develop/dev_history.h"      // dt_dev_transient_params_set()
#include "develop/gui_throttle.h"     // dt_gui_throttle_get_pipe_runtime_us(), DT_THROTTLE_SLOT_MAIN
#include "develop/imageop_gui.h"      // dt_iop_gui_data()
#include "system/dtpthread.h"         // dt_pthread_mutex_t
#include "common/times.h"             // dt_get_wtime()
#include "system/macros.h"            // IS_NULL_PTR()
 
typedef enum drawlayer_rt_worker_kind_t
{
  DRAWLAYER_RT_WORKER_BACKEND = 0,
  DRAWLAYER_RT_WORKER_COUNT = 1,
} drawlayer_rt_worker_kind_t;
 
typedef void (*drawlayer_rt_sample_cb)(dt_iop_module_t *self, dt_drawlayer_worker_t *rt,
                                       const dt_drawlayer_paint_raw_input_t *input);
typedef void (*drawlayer_rt_stroke_end_cb)(dt_iop_module_t *self, dt_drawlayer_worker_t *rt);
typedef void (*drawlayer_rt_idle_cb)(dt_iop_module_t *self, dt_drawlayer_worker_t *rt);
 
typedef struct drawlayer_rt_callbacks_t
{
  const char *thread_name;                     
  drawlayer_rt_sample_cb process_sample;       
  drawlayer_rt_stroke_end_cb process_stroke_end;
  drawlayer_rt_idle_cb on_idle;                
} drawlayer_rt_callbacks_t;
 
typedef struct drawlayer_rt_worker_t
{
  pthread_t thread;                              
  gboolean thread_started;                       
  dt_drawlayer_paint_raw_input_t *ring;          
  guint ring_capacity;                           
  guint ring_head;                               
  guint ring_tail;                               
  guint ring_count;                              
  dt_drawlayer_worker_state_t state;             
  gboolean stop;                                 
} drawlayer_rt_worker_t;
 
struct dt_drawlayer_worker_t
{
  dt_iop_module_t *self;                        
  gboolean *painting;                           
  gboolean *finish_commit_pending;              
  guint *stroke_sample_count;                   
  uint32_t *current_stroke_batch;               
  dt_pthread_mutex_t worker_mutex;              
  pthread_cond_t worker_cond;                   
  drawlayer_rt_worker_t workers[DRAWLAYER_RT_WORKER_COUNT]; 
  GArray *backend_history;                      
  GArray *stroke_raw_inputs;                    
  dt_drawlayer_paint_stroke_t *stroke;          
  dt_drawlayer_damaged_rect_t *backend_path;    
  dt_drawlayer_cache_patch_t heartbeat_patch;   
  dt_drawlayer_cache_patch_t heartbeat_stroke_mask; 
  float *heartbeat_transmittance;               
  float *heartbeat_noise;                       
  size_t heartbeat_transmittance_capacity;      
  gint64 live_publish_ts;                       
  uint32_t live_publish_serial;                 
  dt_drawlayer_damaged_rect_t live_publish_damage; 
  guint commit_idle_id;                         
  dt_iop_drawlayer_params_t publish_params;     
};
 
typedef struct drawlayer_paint_backend_ctx_t
{
  dt_iop_module_t *self;
  dt_drawlayer_worker_t *worker;
  dt_drawlayer_paint_stroke_t *stroke;
} drawlayer_paint_backend_ctx_t;
 
static gboolean _paint_build_dab_cb(void *user_data, dt_drawlayer_paint_stroke_t *state,
                                    const dt_drawlayer_paint_raw_input_t *input, dt_drawlayer_brush_dab_t *out_dab);
static void _paint_stroke_seed_cb(void *user_data, uint64_t stroke_seed);
static void _publish_backend_progress(drawlayer_paint_backend_ctx_t *ctx, gboolean flush_pending);
static gboolean _commit_dabs_on_gui_thread(gpointer user_data);
static void _cancel_pending_gui_commit(dt_drawlayer_worker_t *rt);
static void _process_backend_input(dt_iop_module_t *self, const dt_drawlayer_paint_raw_input_t *input,
                                   dt_drawlayer_paint_stroke_t *stroke);
static gboolean _process_backend_dab(const dt_drawlayer_brush_dab_t *dab, drawlayer_paint_backend_ctx_t *ctx,
                                     const dt_drawlayer_cache_patch_t *sample_patch,
                                     dt_drawlayer_cache_patch_t *patch,
                                     dt_drawlayer_cache_patch_t *stroke_mask,
                                     dt_drawlayer_damaged_rect_t *batch_damage);
static inline drawlayer_rt_worker_t *_backend_worker(dt_drawlayer_worker_t *rt);
static inline const drawlayer_rt_worker_t *_backend_worker_const(const dt_drawlayer_worker_t *rt);
static inline gint64 _live_publish_interval_us(void);
static inline gboolean _live_publish_deadline_reached(const dt_drawlayer_worker_t *rt, const gint64 input_ts,
                                                      const gint64 interval_us);
static inline drawlayer_paint_backend_ctx_t _make_backend_ctx(dt_iop_module_t *self, dt_drawlayer_worker_t *worker,
                                                              dt_drawlayer_paint_stroke_t *stroke);
static guint _rasterize_pending_dab_batch(drawlayer_paint_backend_ctx_t *ctx, gint64 budget_us);
static gboolean _rt_queue_pop_locked(dt_drawlayer_worker_t *rt,
                                     dt_drawlayer_paint_raw_input_t *event);
static guint _worker_batch_min_size(void);
static void _log_worker_batch_timing(const char *tag, guint processed_dabs, guint thread_count, double elapsed_ms,
                                     gboolean outer_loop);
static gboolean _dab_bounds_in_patch(const dt_drawlayer_cache_patch_t *patch, float scale,
                                     const dt_drawlayer_brush_dab_t *dab, dt_drawlayer_damaged_rect_t *bounds);
#if defined(_OPENMP) && OUTER_LOOP
static guint _rasterize_dab_batch_outer_loop(const GArray *dabs, guint max_dabs, float distance_percent,
                                             const dt_drawlayer_cache_patch_t *sample_patch,
                                             dt_drawlayer_cache_patch_t *patch, float scale,
                                             dt_drawlayer_cache_patch_t *stroke_mask,
                                             dt_drawlayer_damaged_rect_t *batch_damage,
                                             const char *tag);
static gboolean _dab_batch_supports_outer_loop(const GArray *dabs, guint count);
#endif
 
/* GUI worker painting into uint8 buffers is deimplemented. Realtime preview
 * now relies on the regular pipeline/backbuffer path. */
 
#if defined(_OPENMP) && OUTER_LOOP
#include <omp.h>
#endif
 
#define DRAWLAYER_BATCH_TILE_SIZE 128
#define DRAWLAYER_HEARTBEAT_PATCH_NAME "drawlayer heartbeat patch"
#define DRAWLAYER_HEARTBEAT_MASK_NAME "drawlayer heartbeat stroke mask"
#define DRAWLAYER_OUTER_LIVE_BATCH_MULTIPLIER 2u
 
gboolean dt_drawlayer_build_worker_input_dab(dt_iop_module_t *self, dt_drawlayer_paint_stroke_t *state,
                                             const dt_drawlayer_paint_raw_input_t *input,
                                             dt_drawlayer_brush_dab_t *dab)
{
  if(IS_NULL_PTR(self) || IS_NULL_PTR(state) || IS_NULL_PTR(input) || IS_NULL_PTR(dab)) return FALSE;
 
  float lx = input->lx;
  float ly = input->ly;
  if(!input->have_layer_coords && !dt_drawlayer_widget_to_layer_coords(self, input->wx, input->wy, &lx, &ly))
    return FALSE;
 
  const float pressure_norm = _clamp01(input->pressure);
  const float tilt_norm = _clamp01(input->tilt);
  const float accel_norm = _clamp01(input->acceleration);
  const gboolean map_pressure_size = (input->map_flags & DRAWLAYER_INPUT_MAP_PRESSURE_SIZE) != 0u;
  const gboolean map_pressure_opacity = (input->map_flags & DRAWLAYER_INPUT_MAP_PRESSURE_OPACITY) != 0u;
  const gboolean map_pressure_flow = (input->map_flags & DRAWLAYER_INPUT_MAP_PRESSURE_FLOW) != 0u;
  const gboolean map_pressure_softness = (input->map_flags & DRAWLAYER_INPUT_MAP_PRESSURE_SOFTNESS) != 0u;
  const gboolean map_tilt_size = (input->map_flags & DRAWLAYER_INPUT_MAP_TILT_SIZE) != 0u;
  const gboolean map_tilt_opacity = (input->map_flags & DRAWLAYER_INPUT_MAP_TILT_OPACITY) != 0u;
  const gboolean map_tilt_flow = (input->map_flags & DRAWLAYER_INPUT_MAP_TILT_FLOW) != 0u;
  const gboolean map_tilt_softness = (input->map_flags & DRAWLAYER_INPUT_MAP_TILT_SOFTNESS) != 0u;
  const gboolean map_accel_size = (input->map_flags & DRAWLAYER_INPUT_MAP_ACCEL_SIZE) != 0u;
  const gboolean map_accel_opacity = (input->map_flags & DRAWLAYER_INPUT_MAP_ACCEL_OPACITY) != 0u;
  const gboolean map_accel_flow = (input->map_flags & DRAWLAYER_INPUT_MAP_ACCEL_FLOW) != 0u;
  const gboolean map_accel_softness = (input->map_flags & DRAWLAYER_INPUT_MAP_ACCEL_SOFTNESS) != 0u;
  const drawlayer_mapping_profile_t pressure_profile = (drawlayer_mapping_profile_t)CLAMP(
      (int)input->pressure_profile, (int)DRAWLAYER_PROFILE_LINEAR, (int)DRAWLAYER_PROFILE_INV_QUADRATIC);
  const drawlayer_mapping_profile_t tilt_profile = (drawlayer_mapping_profile_t)CLAMP(
      (int)input->tilt_profile, (int)DRAWLAYER_PROFILE_LINEAR, (int)DRAWLAYER_PROFILE_INV_QUADRATIC);
  const drawlayer_mapping_profile_t accel_profile = (drawlayer_mapping_profile_t)CLAMP(
      (int)input->accel_profile, (int)DRAWLAYER_PROFILE_LINEAR, (int)DRAWLAYER_PROFILE_INV_QUADRATIC);
  const float pressure_coeff = _mapping_profile_value(pressure_profile, pressure_norm);
  const float tilt_coeff = _mapping_profile_value(tilt_profile, tilt_norm);
  const float accel_coeff = _mapping_profile_value(accel_profile, accel_norm);
 
  float radius = fmaxf(input->brush_radius, 0.5f);
  float opacity = _clamp01(input->brush_opacity);
  float flow = _clamp01(input->brush_flow);
  const float sprinkles = _clamp01(input->brush_sprinkles);
  float hardness = _clamp01(input->brush_hardness);
  const float base_radius = radius;
  const float base_opacity = opacity;
  const float base_flow = flow;
  const float base_hardness = hardness;
 
  if(map_pressure_size) radius *= pressure_coeff;
  if(map_pressure_opacity) opacity *= pressure_coeff;
  if(map_pressure_flow) flow *= pressure_coeff;
  if(map_pressure_softness) hardness *= pressure_coeff;
 
  if(map_tilt_size) radius *= tilt_coeff;
  if(map_tilt_opacity) opacity *= tilt_coeff;
  if(map_tilt_flow) flow *= tilt_coeff;
  if(map_tilt_softness) hardness *= tilt_coeff;
 
  if(map_accel_size) radius *= accel_coeff;
  if(map_accel_opacity) opacity *= accel_coeff;
  if(map_accel_flow) flow *= accel_coeff;
  if(map_accel_softness) hardness *= accel_coeff;
 
  radius = fmaxf(radius, 0.5f);
  hardness = _clamp01(hardness);
  float dir_x = 0.0f;
  float dir_y = 0.0f;
  if(state->have_last_input_dab)
  {
    const float dx = lx - state->last_input_dab.x;
    const float dy = ly - state->last_input_dab.y;
    const float dir_len = hypotf(dx, dy);
    if(dir_len > 1e-6f)
    {
      dir_x = dx / dir_len;
      dir_y = dy / dir_len;
    }
  }
 
  *dab = (dt_drawlayer_brush_dab_t){
    .x = lx,
    .y = ly,
    .radius = radius,
    .dir_x = dir_x,
    .dir_y = dir_y,
    .opacity = _clamp01(opacity),
    .flow = _clamp01(flow),
    .sprinkles = _clamp01(sprinkles),
    .sprinkle_size = input->brush_sprinkle_size,
    .sprinkle_coarseness = _clamp01(input->brush_sprinkle_coarseness),
    .hardness = hardness,
    .color = { input->color[0], input->color[1], input->color[2], 1.0f },
    .display_color = { input->display_color[0], input->display_color[1], input->display_color[2] },
    .shape = input->brush_shape,
    .mode = input->brush_mode,
    .stroke_batch = input->stroke_batch,
    .stroke_pos = input->stroke_pos,
  };
 
  if((map_pressure_size || map_pressure_opacity || map_pressure_flow || map_pressure_softness || map_tilt_size
      || map_tilt_opacity || map_tilt_flow || map_tilt_softness || map_accel_size || map_accel_opacity
      || map_accel_flow || map_accel_softness)
     && (input->stroke_pos != DT_DRAWLAYER_PAINT_STROKE_MIDDLE
         || ((state->history && (state->history->len & 15u) == 0u))))
  {
    dt_print(DT_DEBUG_INPUT,
             "[drawlayer] map p=%.4f t=%.4f a=%.4f coeff[p=%.4f t=%.4f a=%.4f] "
             "base[r=%.2f o=%.3f f=%.3f h=%.3f] out[r=%.2f o=%.3f f=%.3f h=%.3f] "
             "flags[p=%d%d%d%d t=%d%d%d%d a=%d%d%d%d]\n",
             pressure_norm, tilt_norm, accel_norm, pressure_coeff, tilt_coeff, accel_coeff, base_radius,
             base_opacity, base_flow, base_hardness, radius, _clamp01(opacity), _clamp01(flow), _clamp01(hardness),
             map_pressure_size ? 1 : 0, map_pressure_opacity ? 1 : 0, map_pressure_flow ? 1 : 0,
             map_pressure_softness ? 1 : 0, map_tilt_size ? 1 : 0, map_tilt_opacity ? 1 : 0, map_tilt_flow ? 1 : 0,
             map_tilt_softness ? 1 : 0, map_accel_size ? 1 : 0, map_accel_opacity ? 1 : 0, map_accel_flow ? 1 : 0,
             map_accel_softness ? 1 : 0);
  }
 
  return TRUE;
}
 
static gboolean _paint_build_dab_cb(void *user_data, dt_drawlayer_paint_stroke_t *state,
                                    const dt_drawlayer_paint_raw_input_t *input, dt_drawlayer_brush_dab_t *out_dab)
{
  drawlayer_paint_backend_ctx_t *ctx = (drawlayer_paint_backend_ctx_t *)user_data;
  return (ctx && ctx->self)
             ? dt_drawlayer_build_worker_input_dab(ctx->self, state, (const dt_drawlayer_paint_raw_input_t *)input,
                                                   (dt_drawlayer_brush_dab_t *)out_dab)
             : FALSE;
}
 
 
static void _paint_stroke_seed_cb(void *user_data, uint64_t stroke_seed)
{
  drawlayer_paint_backend_ctx_t *ctx = (drawlayer_paint_backend_ctx_t *)user_data;
  if(IS_NULL_PTR(ctx)) return;
  if(ctx->stroke) dt_drawlayer_paint_runtime_set_stroke_seed(ctx->stroke, stroke_seed);
}
 
static void _publish_backend_progress(drawlayer_paint_backend_ctx_t *ctx, gboolean flush_pending)
{
  if(IS_NULL_PTR(ctx) || IS_NULL_PTR(ctx->self) || !flush_pending) return;
 
  dt_iop_module_t *self = ctx->self;
  dt_iop_drawlayer_gui_data_t *g = (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(ctx->self);
  dt_iop_drawlayer_params_t *params = IS_NULL_PTR(ctx->worker) ? NULL : &ctx->worker->publish_params;
  dt_develop_t *dev = self->dev;
  if(IS_NULL_PTR(ctx->worker) || IS_NULL_PTR(g) || IS_NULL_PTR(params) || IS_NULL_PTR(dev) || !ctx->worker->live_publish_damage.valid) return;
 
  ctx->worker->live_publish_serial++;
  dt_drawlayer_paint_runtime_state_reset(&ctx->worker->live_publish_damage);
  ctx->worker->live_publish_ts = g_get_monotonic_time();
 
  const int sample_count = (int)g->stroke.stroke_sample_count;
  dt_drawlayer_touch_stroke_commit_hash(params, sample_count, g->stroke.last_dab_valid, g->stroke.last_dab_x,
                                        g->stroke.last_dab_y, ctx->worker->live_publish_serial);
 
  /* Realtime heartbeats publish the live params through the thread-safe transient channel instead of
   * writing permanent history. This re-renders the in-progress stroke (the bumped stroke_commit_hash
   * re-keys the drawlayer piece's global_hash) without churning the undo stack or the database. The
   * permanent history is written once, at the real commit (`dt_drawlayer_commit_dabs`), which also
   * clears the transient slot. drawlayer does not change geometry, so a fast main-pipe top-only resync
   * (`_sync_focused_in_place`) is enough — flag it explicitly since _set no longer auto-triggers.
   *
   * `params` is the WORKER'S OWN blob, seeded from `self->params` on the GUI thread at stroke
   * begin. It is not `self->params`: that one belongs to the GUI thread, and bumping its hash
   * here was an unsynchronised read-modify-write of a struct carrying two strings. The transient
   * channel deep-copies what it is given, so a private blob is all it needs. Consequence worth
   * knowing: the hash the COMMIT chains from is now the previous commit's rather than the last
   * heartbeat's, which makes the committed value deterministic instead of a function of how many
   * heartbeats happened to fire. */
  dt_dev_transient_params_set(self, params, self->params_size, NULL, 0);
  dt_dev_pixelpipe_or_changed(dev->pipe, DT_DEV_PIPE_TOP_CHANGED);
  dt_control_queue_redraw_center();
 
  dt_print(DT_DEBUG_PERF, "[drawlayer] publish serial=%u hash=%u dabs=%d\n",
           ctx->worker->live_publish_serial, params->stroke_commit_hash, sample_count);
}
 
static void _process_backend_input(dt_iop_module_t *self, const dt_drawlayer_paint_raw_input_t *input,
                                   dt_drawlayer_paint_stroke_t *stroke)
{
  dt_iop_drawlayer_gui_data_t *g = self ? (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self) : NULL;
  if(IS_NULL_PTR(g) || IS_NULL_PTR(input) || IS_NULL_PTR(stroke)) return;
 
  drawlayer_paint_backend_ctx_t ctx = _make_backend_ctx(self, g->stroke.worker, stroke);
  const dt_drawlayer_paint_callbacks_t callbacks = {
    .build_dab = _paint_build_dab_cb,
    .on_stroke_seed = _paint_stroke_seed_cb,
  };
  if(!dt_drawlayer_paint_queue_raw_input(stroke, input)) return;
  dt_drawlayer_paint_interpolate_path(stroke, &callbacks, &ctx);
 
  if(stroke->pending_dabs && stroke->pending_dabs->len > 0)
  {
    const gint64 live_publish_interval_us = _live_publish_interval_us();
    const gint64 input_ts = input->event_ts ? input->event_ts : g_get_monotonic_time();
    if(ctx.worker && ctx.worker->live_publish_ts == 0)
      ctx.worker->live_publish_ts = input_ts - live_publish_interval_us;
 
    if(_live_publish_deadline_reached(ctx.worker, input_ts, live_publish_interval_us))
    {
      const guint processed_dabs = _rasterize_pending_dab_batch(&ctx, live_publish_interval_us);
      if(processed_dabs > 0) _publish_backend_progress(&ctx, TRUE);
    }
  }
}
 
void dt_drawlayer_worker_publish_backend_stroke_damage(dt_iop_module_t *self)
{
  dt_iop_drawlayer_gui_data_t *g = self ? (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self) : NULL;
  if(IS_NULL_PTR(g)) return;
 
  dt_drawlayer_damaged_rect_t backend_damage = { 0 };
  if(g->stroke.worker && dt_drawlayer_paint_merge_runtime_stroke_damage(g->stroke.worker->backend_path, &backend_damage))
  {
    g->process.cache_dirty = TRUE;
    dt_drawlayer_paint_runtime_note_dab_damage(&g->process.cache_dirty_rect, &backend_damage);
  }
}
 
static gboolean _process_backend_dab(const dt_drawlayer_brush_dab_t *dab, drawlayer_paint_backend_ctx_t *ctx,
                                     const dt_drawlayer_cache_patch_t *sample_patch,
                                     dt_drawlayer_cache_patch_t *patch,
                                     dt_drawlayer_cache_patch_t *stroke_mask,
                                     dt_drawlayer_damaged_rect_t *batch_damage)
{
  dt_drawlayer_paint_stroke_t *stroke = ctx ? ctx->stroke : NULL;
  if(IS_NULL_PTR(ctx) || !stroke || !stroke->dab_window || IS_NULL_PTR(dab) || IS_NULL_PTR(patch) || IS_NULL_PTR(patch->pixels) || !stroke_mask
     || !stroke_mask->pixels)
    return FALSE;
 
  dt_drawlayer_damaged_rect_t step_damage = { 0 };
  if(!dt_drawlayer_paint_rasterize_segment_to_buffer(dab, _clamp01(stroke->distance_percent), sample_patch,
                                                     patch, 1.0f, stroke_mask, &step_damage, stroke))
    return FALSE;
 
  if(step_damage.valid && batch_damage)
    dt_drawlayer_paint_runtime_note_dab_damage(batch_damage, &step_damage);
  
  return step_damage.valid;
}
 
static const drawlayer_rt_callbacks_t _rt_callbacks[DRAWLAYER_RT_WORKER_COUNT];
static void _stop_worker(dt_iop_module_t *self, dt_drawlayer_worker_t *rt);
 
static void _stroke_destroy(dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return;
  if(rt->stroke && rt->stroke->pending_dabs)
  {
    g_array_free(rt->stroke->pending_dabs, TRUE);
    rt->stroke->pending_dabs = NULL;
  }
  if(rt->stroke && rt->stroke->dab_window)
  {
    g_array_free(rt->stroke->dab_window, TRUE);
    rt->stroke->dab_window = NULL;
  }
  dt_drawlayer_paint_runtime_private_destroy(&rt->stroke);
}
 
static gboolean _stroke_create(dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return FALSE;
  if(rt->stroke) return TRUE;
  rt->stroke = dt_drawlayer_paint_runtime_private_create();
  if(IS_NULL_PTR(rt->stroke)) return FALSE;
  rt->stroke->history = rt->backend_history;
  rt->stroke->pending_dabs = g_array_new(FALSE, FALSE, sizeof(dt_drawlayer_brush_dab_t));
  if(!rt->stroke->pending_dabs)
  {
    dt_drawlayer_paint_runtime_private_destroy(&rt->stroke);
    return FALSE;
  }
  rt->stroke->dab_window = g_array_new(FALSE, FALSE, sizeof(dt_drawlayer_brush_dab_t));
  if(!rt->stroke->dab_window)
  {
    g_array_free(rt->stroke->pending_dabs, TRUE);
    rt->stroke->pending_dabs = NULL;
    dt_drawlayer_paint_runtime_private_destroy(&rt->stroke);
    return FALSE;
  }
  return TRUE;
}
 
static gboolean _stroke_begin(dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return FALSE;
  if(!rt->backend_history)
    rt->backend_history = g_array_new(FALSE, FALSE, sizeof(dt_drawlayer_brush_dab_t));
  if(IS_NULL_PTR(rt->backend_history)) return FALSE;
  if(!rt->stroke_raw_inputs)
    rt->stroke_raw_inputs = g_array_new(FALSE, FALSE, sizeof(dt_drawlayer_paint_raw_input_t));
  if(IS_NULL_PTR(rt->stroke_raw_inputs)) return FALSE;
  if(!_stroke_create(rt)) return FALSE;
  rt->stroke->history = rt->backend_history;
  dt_drawlayer_paint_path_state_reset(rt->stroke);
  dt_drawlayer_paint_runtime_private_reset(rt->stroke);
  g_array_set_size(rt->backend_history, 0);
  g_array_set_size(rt->stroke_raw_inputs, 0);
  return TRUE;
}
 
static void _stroke_clear(dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return;
  if(rt->backend_history) g_array_set_size(rt->backend_history, 0);
  if(rt->stroke_raw_inputs) g_array_set_size(rt->stroke_raw_inputs, 0);
  if(rt->stroke)
  {
    dt_drawlayer_paint_path_state_reset(rt->stroke);
    dt_drawlayer_paint_runtime_private_reset(rt->stroke);
  }
}
 
static void _reset_backend_path(dt_drawlayer_worker_t *rt)
{
  if(!IS_NULL_PTR(rt) && rt->backend_path) dt_drawlayer_paint_runtime_state_reset(rt->backend_path);
}
 
static void _reset_live_publish(dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return;
  rt->live_publish_ts = 0;
  rt->live_publish_serial = 0;
  dt_drawlayer_paint_runtime_state_reset(&rt->live_publish_damage);
}
 
static inline drawlayer_rt_worker_t *_backend_worker(dt_drawlayer_worker_t *rt)
{
  return rt ? &rt->workers[DRAWLAYER_RT_WORKER_BACKEND] : NULL;
}
 
static inline const drawlayer_rt_worker_t *_backend_worker_const(const dt_drawlayer_worker_t *rt)
{
  return rt ? &rt->workers[DRAWLAYER_RT_WORKER_BACKEND] : NULL;
}
 
static inline gint64 _live_publish_interval_us(void)
{
  return MAX((gint64)dt_gui_throttle_get_pipe_runtime_us(DT_THROTTLE_SLOT_MAIN), (gint64)20000);
}
 
static guint _worker_batch_min_size(void)
{
#if defined(_OPENMP) && OUTER_LOOP
  return MAX(1, omp_get_max_threads());
#else
  return 1;
#endif
}
 
#if defined(_OPENMP) && OUTER_LOOP
static gboolean _dab_batch_supports_outer_loop(const GArray *dabs, const guint count)
{
  if(IS_NULL_PTR(dabs) || count == 0) return FALSE;
  for(guint i = 0; i < count; i++)
  {
    const dt_drawlayer_brush_dab_t *dab = &g_array_index(dabs, dt_drawlayer_brush_dab_t, i);
    if(dab->mode == DT_DRAWLAYER_BRUSH_MODE_SMUDGE) return FALSE;
  }
  return TRUE;
}
#endif
 
static void _log_worker_batch_timing(const char *tag, const guint processed_dabs, const guint thread_count,
                                     const double elapsed_ms, const gboolean outer_loop)
{
  if(!(dt_get_debug_flags() & DT_DEBUG_PERF)) return;
  dt_print(DT_DEBUG_PERF, "[drawlayer] batch worker=%s dabs=%u threads=%u outer=%d ms=%.3f\n",
           tag ? tag : "unknown", processed_dabs, thread_count, outer_loop ? 1 : 0, elapsed_ms);
}
 
static inline gboolean _live_publish_deadline_reached(const dt_drawlayer_worker_t *rt, const gint64 input_ts,
                                                      const gint64 interval_us)
{
  return rt && input_ts - rt->live_publish_ts >= interval_us;
}
 
static inline drawlayer_paint_backend_ctx_t _make_backend_ctx(dt_iop_module_t *self, dt_drawlayer_worker_t *worker,
                                                              dt_drawlayer_paint_stroke_t *stroke)
{
  return (drawlayer_paint_backend_ctx_t){
    .self = self,
    .worker = worker,
    .stroke = stroke,
  };
}
 
static gboolean _dab_bounds_in_patch(const dt_drawlayer_cache_patch_t *patch, const float scale,
                                     const dt_drawlayer_brush_dab_t *dab, dt_drawlayer_damaged_rect_t *bounds)
{
  if(bounds) *bounds = (dt_drawlayer_damaged_rect_t){ 0 };
  if(IS_NULL_PTR(patch) || IS_NULL_PTR(dab) || IS_NULL_PTR(bounds) || IS_NULL_PTR(patch->pixels) || patch->width <= 0 || patch->height <= 0
     || dab->radius <= 0.0f || dab->opacity <= 0.0f || scale <= 0.0f)
    return FALSE;
 
  const float support_radius = dab->radius;
  bounds->valid = TRUE;
  bounds->nw[0] = MAX(0, (int)floorf((dab->x - support_radius) * scale) - patch->x);
  bounds->nw[1] = MAX(0, (int)floorf((dab->y - support_radius) * scale) - patch->y);
  bounds->se[0] = MIN(patch->width, (int)ceilf((dab->x + support_radius) * scale) - patch->x + 1);
  bounds->se[1] = MIN(patch->height, (int)ceilf((dab->y + support_radius) * scale) - patch->y + 1);
  return bounds->se[0] > bounds->nw[0] && bounds->se[1] > bounds->nw[1];
}
 
static gboolean _collect_batch_bounds(const GArray *dabs, const guint max_dabs,
                                      const dt_drawlayer_cache_patch_t *patch,
                                      dt_drawlayer_damaged_rect_t *batch_bounds)
{
  if(batch_bounds) *batch_bounds = (dt_drawlayer_damaged_rect_t){ 0 };
  if(IS_NULL_PTR(dabs) || max_dabs == 0 || IS_NULL_PTR(patch) || IS_NULL_PTR(batch_bounds)) return FALSE;
 
  /* Walk the upcoming batch in FIFO order and union every dab footprint that
   * can touch the destination patch. This keeps the worker scratch patch as
   * small as possible while still covering all writes for the current heartbeat. */
  for(guint i = 0; i < max_dabs; i++)
  {
    dt_drawlayer_damaged_rect_t dab_bounds = { 0 };
    const dt_drawlayer_brush_dab_t *dab = &g_array_index(dabs, dt_drawlayer_brush_dab_t, i);
    if(_dab_bounds_in_patch(patch, 1.0f, dab, &dab_bounds))
      dt_drawlayer_paint_runtime_note_dab_damage(batch_bounds, &dab_bounds);
  }
 
  return batch_bounds->valid;
}
 
static gboolean _ensure_heartbeat_batch_buffers(dt_drawlayer_worker_t *rt,
                                                const dt_drawlayer_damaged_rect_t *batch_bounds)
{
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(batch_bounds) || !batch_bounds->valid) return FALSE;
 
  const int width = batch_bounds->se[0] - batch_bounds->nw[0];
  const int height = batch_bounds->se[1] - batch_bounds->nw[1];
  if(width <= 0 || height <= 0) return FALSE;
  if(!dt_drawlayer_cache_ensure_process_patch_buffer(&rt->heartbeat_patch, &rt->heartbeat_stroke_mask,
                                                     width, height, DRAWLAYER_HEARTBEAT_PATCH_NAME,
                                                     DRAWLAYER_HEARTBEAT_MASK_NAME))
    return FALSE;
 
  const size_t needed = (size_t)width * height;
  if(rt->heartbeat_transmittance_capacity < needed)
  {
    float *const grown = g_realloc_n(rt->heartbeat_transmittance, needed, sizeof(*grown));
    if(IS_NULL_PTR(grown)) return FALSE;
    rt->heartbeat_transmittance = grown;
 
    float *const grown_noise = g_realloc_n(rt->heartbeat_noise, needed, sizeof(*grown_noise));
    if(IS_NULL_PTR(grown_noise)) return FALSE;
    rt->heartbeat_noise = grown_noise;
 
    rt->heartbeat_transmittance_capacity = needed;
  }
 
  rt->heartbeat_patch.x = batch_bounds->nw[0];
  rt->heartbeat_patch.y = batch_bounds->nw[1];
  rt->heartbeat_stroke_mask.x = batch_bounds->nw[0];
  rt->heartbeat_stroke_mask.y = batch_bounds->nw[1];
  return TRUE;
}
 
static void _copy_rgba_batch_from_locked_patch(const dt_drawlayer_cache_patch_t *src,
                                               dt_drawlayer_cache_patch_t *dst)
{
  if(IS_NULL_PTR(src) || IS_NULL_PTR(dst) || IS_NULL_PTR(src->pixels) || IS_NULL_PTR(dst->pixels) || dst->width <= 0 || dst->height <= 0) return;
 
  const int src_x0 = dst->x - src->x;
  const int src_y0 = dst->y - src->y;
  if(src_x0 < 0 || src_y0 < 0 || src_x0 + dst->width > src->width || src_y0 + dst->height > src->height) return;
 
  for(int y = 0; y < dst->height; y++)
  {
    const float *src_row = src->pixels + 4 * ((size_t)(src_y0 + y) * src->width + src_x0);
    float *dst_row = dst->pixels + 4 * ((size_t)y * dst->width);
    memcpy(dst_row, src_row, (size_t)dst->width * 4 * sizeof(float));
  }
}
 
static void _copy_mask_batch_from_locked_patch(const dt_drawlayer_cache_patch_t *src,
                                               dt_drawlayer_cache_patch_t *dst)
{
  if(IS_NULL_PTR(dst) || IS_NULL_PTR(dst->pixels) || dst->width <= 0 || dst->height <= 0) return;
  if(IS_NULL_PTR(src) || IS_NULL_PTR(src->pixels))
  {
    memset(dst->pixels, 0, (size_t)dst->width * dst->height * sizeof(float));
    return;
  }
 
  const int src_x0 = dst->x - src->x;
  const int src_y0 = dst->y - src->y;
  if(src_x0 < 0 || src_y0 < 0 || src_x0 + dst->width > src->width || src_y0 + dst->height > src->height)
  {
    memset(dst->pixels, 0, (size_t)dst->width * dst->height * sizeof(float));
    return;
  }
 
  for(int y = 0; y < dst->height; y++)
  {
    const float *src_row = src->pixels + (size_t)(src_y0 + y) * src->width + src_x0;
    float *dst_row = dst->pixels + (size_t)y * dst->width;
    memcpy(dst_row, src_row, (size_t)dst->width * sizeof(float));
  }
}
 
static gboolean _translate_batch_damage(const dt_drawlayer_cache_patch_t *patch,
                                        const dt_drawlayer_damaged_rect_t *local_damage,
                                        dt_drawlayer_damaged_rect_t *absolute_damage)
{
  if(absolute_damage) *absolute_damage = (dt_drawlayer_damaged_rect_t){ 0 };
  if(IS_NULL_PTR(patch) || IS_NULL_PTR(local_damage) || !local_damage->valid || IS_NULL_PTR(absolute_damage)) return FALSE;
 
  *absolute_damage = *local_damage;
  absolute_damage->nw[0] += patch->x;
  absolute_damage->nw[1] += patch->y;
  absolute_damage->se[0] += patch->x;
  absolute_damage->se[1] += patch->y;
  return TRUE;
}
 
static void _copy_rgba_damage_to_locked_patch(const dt_drawlayer_cache_patch_t *src,
                                              const dt_drawlayer_damaged_rect_t *local_damage,
                                              dt_drawlayer_cache_patch_t *dst)
{
  if(IS_NULL_PTR(src) || IS_NULL_PTR(dst) || IS_NULL_PTR(local_damage) || !local_damage->valid || IS_NULL_PTR(src->pixels) || IS_NULL_PTR(dst->pixels)) return;
 
  const int copy_w = local_damage->se[0] - local_damage->nw[0];
  const int copy_h = local_damage->se[1] - local_damage->nw[1];
  if(copy_w <= 0 || copy_h <= 0) return;
 
  const int dst_x0 = src->x + local_damage->nw[0] - dst->x;
  const int dst_y0 = src->y + local_damage->nw[1] - dst->y;
  if(dst_x0 < 0 || dst_y0 < 0 || dst_x0 + copy_w > dst->width || dst_y0 + copy_h > dst->height) return;
 
  for(int y = 0; y < copy_h; y++)
  {
    const float *src_row = src->pixels + 4 * ((size_t)(local_damage->nw[1] + y) * src->width + local_damage->nw[0]);
    float *dst_row = dst->pixels + 4 * ((size_t)(dst_y0 + y) * dst->width + dst_x0);
    memcpy(dst_row, src_row, (size_t)copy_w * 4 * sizeof(float));
  }
}
 
static void _copy_mask_damage_to_locked_patch(const dt_drawlayer_cache_patch_t *src,
                                              const dt_drawlayer_damaged_rect_t *local_damage,
                                              dt_drawlayer_cache_patch_t *dst)
{
  if(IS_NULL_PTR(src) || IS_NULL_PTR(dst) || IS_NULL_PTR(local_damage) || !local_damage->valid || IS_NULL_PTR(src->pixels) || IS_NULL_PTR(dst->pixels)) return;
 
  const int copy_w = local_damage->se[0] - local_damage->nw[0];
  const int copy_h = local_damage->se[1] - local_damage->nw[1];
  if(copy_w <= 0 || copy_h <= 0) return;
 
  const int dst_x0 = src->x + local_damage->nw[0] - dst->x;
  const int dst_y0 = src->y + local_damage->nw[1] - dst->y;
  if(dst_x0 < 0 || dst_y0 < 0 || dst_x0 + copy_w > dst->width || dst_y0 + copy_h > dst->height) return;
 
  for(int y = 0; y < copy_h; y++)
  {
    const float *src_row = src->pixels + (size_t)(local_damage->nw[1] + y) * src->width + local_damage->nw[0];
    float *dst_row = dst->pixels + (size_t)(dst_y0 + y) * dst->width + dst_x0;
    memcpy(dst_row, src_row, (size_t)copy_w * sizeof(float));
  }
}
 
static void _clear_rgba_damage_in_patch(dt_drawlayer_cache_patch_t *patch,
                                        const dt_drawlayer_damaged_rect_t *local_damage)
{
  if(IS_NULL_PTR(patch) || IS_NULL_PTR(local_damage) || !local_damage->valid || IS_NULL_PTR(patch->pixels)) return;
 
  const int clear_w = local_damage->se[0] - local_damage->nw[0];
  const int clear_h = local_damage->se[1] - local_damage->nw[1];
  if(clear_w <= 0 || clear_h <= 0) return;
 
  for(int y = 0; y < clear_h; y++)
  {
    float *row = patch->pixels + 4 * ((size_t)(local_damage->nw[1] + y) * patch->width + local_damage->nw[0]);
    memset(row, 0, (size_t)clear_w * 4 * sizeof(float));
  }
}
 
static void _clear_mask_damage_in_patch(dt_drawlayer_cache_patch_t *patch,
                                        const dt_drawlayer_damaged_rect_t *local_damage)
{
  if(IS_NULL_PTR(patch) || IS_NULL_PTR(local_damage) || !local_damage->valid || IS_NULL_PTR(patch->pixels)) return;
 
  const int clear_w = local_damage->se[0] - local_damage->nw[0];
  const int clear_h = local_damage->se[1] - local_damage->nw[1];
  if(clear_w <= 0 || clear_h <= 0) return;
 
  for(int y = 0; y < clear_h; y++)
  {
    float *row = patch->pixels + (size_t)(local_damage->nw[1] + y) * patch->width + local_damage->nw[0];
    memset(row, 0, (size_t)clear_w * sizeof(float));
  }
}
 
#if defined(_OPENMP) && OUTER_LOOP
static dt_drawlayer_paint_stroke_t *_create_batch_runtime(void)
{
  dt_drawlayer_paint_stroke_t *runtime = dt_drawlayer_paint_runtime_private_create();
  if(IS_NULL_PTR(runtime)) return NULL;
  runtime->dab_window = g_array_new(FALSE, FALSE, sizeof(dt_drawlayer_brush_dab_t));
  if(!runtime->dab_window)
  {
    dt_drawlayer_paint_runtime_private_destroy(&runtime);
    return NULL;
  }
  return runtime;
}
 
static void _destroy_batch_runtime(dt_drawlayer_paint_stroke_t **runtime)
{
  if(!runtime || !*runtime) return;
  if((*runtime)->dab_window) g_array_free((*runtime)->dab_window, TRUE);
  (*runtime)->dab_window = NULL;
  dt_drawlayer_paint_runtime_private_destroy(runtime);
}
 
static void _lock_batch_tiles(omp_lock_t *locks, const int tile_cols, const int tile_origin_x,
                              const int tile_origin_y, const dt_drawlayer_damaged_rect_t *bounds)
{
  if(!locks || tile_cols <= 0 || IS_NULL_PTR(bounds) || !bounds->valid) return;
  const int tx0 = bounds->nw[0] / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_x;
  const int ty0 = bounds->nw[1] / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_y;
  const int tx1 = MAX(tx0, (bounds->se[0] - 1) / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_x);
  const int ty1 = MAX(ty0, (bounds->se[1] - 1) / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_y);
  for(int ty = ty0; ty <= ty1; ty++)
    for(int tx = tx0; tx <= tx1; tx++)
      omp_set_lock(&locks[ty * tile_cols + tx]);
}
 
static void _unlock_batch_tiles(omp_lock_t *locks, const int tile_cols, const int tile_origin_x,
                                const int tile_origin_y, const dt_drawlayer_damaged_rect_t *bounds)
{
  if(!locks || tile_cols <= 0 || IS_NULL_PTR(bounds) || !bounds->valid) return;
  const int tx0 = bounds->nw[0] / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_x;
  const int ty0 = bounds->nw[1] / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_y;
  const int tx1 = MAX(tx0, (bounds->se[0] - 1) / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_x);
  const int ty1 = MAX(ty0, (bounds->se[1] - 1) / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_y);
  for(int ty = ty1; ty >= ty0; ty--)
    for(int tx = tx1; tx >= tx0; tx--)
      omp_unset_lock(&locks[ty * tile_cols + tx]);
}
 
static guint _rasterize_dab_batch_outer_loop(const GArray *dabs, const guint max_dabs, const float distance_percent,
                                             const dt_drawlayer_cache_patch_t *sample_patch,
                                             dt_drawlayer_cache_patch_t *patch, const float scale,
                                             dt_drawlayer_cache_patch_t *stroke_mask,
                                             dt_drawlayer_damaged_rect_t *batch_damage,
                                             const char *tag)
{
  if(IS_NULL_PTR(dabs) || max_dabs == 0 || IS_NULL_PTR(patch) || IS_NULL_PTR(patch->pixels) || patch->width <= 0 || patch->height <= 0) return 0;
 
  const guint thread_count = _worker_batch_min_size();
  dt_drawlayer_damaged_rect_t batch_bounds = { 0 };
  for(guint i = 0; i < max_dabs; i++)
  {
    dt_drawlayer_damaged_rect_t dab_bounds = { 0 };
    const dt_drawlayer_brush_dab_t *dab = &g_array_index(dabs, dt_drawlayer_brush_dab_t, i);
    if(_dab_bounds_in_patch(patch, scale, dab, &dab_bounds))
      dt_drawlayer_paint_runtime_note_dab_damage(&batch_bounds, &dab_bounds);
  }
  if(!batch_bounds.valid) return 0;
 
  const int tile_origin_x = batch_bounds.nw[0] / DRAWLAYER_BATCH_TILE_SIZE;
  const int tile_origin_y = batch_bounds.nw[1] / DRAWLAYER_BATCH_TILE_SIZE;
  const int tile_cols = MAX(1, (batch_bounds.se[0] + DRAWLAYER_BATCH_TILE_SIZE - 1) / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_x);
  const int tile_rows = MAX(1, (batch_bounds.se[1] + DRAWLAYER_BATCH_TILE_SIZE - 1) / DRAWLAYER_BATCH_TILE_SIZE - tile_origin_y);
  dt_drawlayer_paint_stroke_t **thread_runtime = g_malloc0((size_t)thread_count * sizeof(*thread_runtime));
  dt_drawlayer_damaged_rect_t *thread_damage = g_malloc0((size_t)thread_count * sizeof(*thread_damage));
  omp_lock_t *tile_locks = g_malloc0((size_t)tile_cols * tile_rows * sizeof(*tile_locks));
  if(!thread_runtime || IS_NULL_PTR(thread_damage) || !tile_locks)
  {
    g_free(thread_runtime);
    g_free(thread_damage);
    g_free(tile_locks);
    return 0;
  }
 
  for(guint i = 0; i < thread_count; i++)
  {
    thread_runtime[i] = _create_batch_runtime();
    if(!thread_runtime[i])
    {
      for(guint k = 0; k < i; k++) _destroy_batch_runtime(&thread_runtime[k]);
      g_free(thread_runtime);
      g_free(thread_damage);
      g_free(tile_locks);
      return 0;
    }
  }
 
  for(int i = 0; i < tile_cols * tile_rows; i++)
    omp_init_lock(&tile_locks[i]);
 
  const double t0 = dt_get_wtime();
#pragma omp parallel for default(shared)
  for(guint i = 0; i < max_dabs; i++)
  {
    const int tid = omp_get_thread_num();
    dt_drawlayer_paint_stroke_t *runtime = thread_runtime[tid];
    dt_drawlayer_damaged_rect_t runtime_damage = { 0 };
    dt_drawlayer_damaged_rect_t dab_damage = { 0 };
    dt_drawlayer_damaged_rect_t bounds = { 0 };
    const dt_drawlayer_brush_dab_t *dab = &g_array_index(dabs, dt_drawlayer_brush_dab_t, i);
 
    dt_drawlayer_paint_path_state_reset(runtime);
    dt_drawlayer_paint_runtime_private_reset(runtime);
    if(runtime->dab_window) g_array_set_size(runtime->dab_window, 0);
    if(!_dab_bounds_in_patch(patch, scale, dab, &bounds))
      continue;
 
    _lock_batch_tiles(tile_locks, tile_cols, tile_origin_x, tile_origin_y, &bounds);
    dt_drawlayer_paint_rasterize_segment_to_buffer(dab, distance_percent, sample_patch, patch, scale, stroke_mask,
                                                   &runtime_damage, runtime);
    _unlock_batch_tiles(tile_locks, tile_cols, tile_origin_x, tile_origin_y, &bounds);
 
    if(dt_drawlayer_paint_runtime_get_stroke_damage(&runtime_damage, &dab_damage))
      dt_drawlayer_paint_runtime_note_dab_damage(&thread_damage[tid], &dab_damage);
  }
  const double t1 = dt_get_wtime();
 
  if(batch_damage) dt_drawlayer_paint_runtime_state_reset(batch_damage);
  for(guint i = 0; i < thread_count; i++)
  {
    if(batch_damage) dt_drawlayer_paint_runtime_note_dab_damage(batch_damage, &thread_damage[i]);
    _destroy_batch_runtime(&thread_runtime[i]);
  }
  for(int i = 0; i < tile_cols * tile_rows; i++)
    omp_destroy_lock(&tile_locks[i]);
 
  g_free(thread_runtime);
  g_free(thread_damage);
  g_free(tile_locks);
 
  _log_worker_batch_timing(tag, max_dabs, thread_count, 1000.0 * (t1 - t0), TRUE);
  return max_dabs;
}
#endif
 
static guint _rasterize_pending_dab_batch(drawlayer_paint_backend_ctx_t *ctx, gint64 budget_us)
{
  dt_iop_drawlayer_gui_data_t *g = (ctx && ctx->self) ? (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(ctx->self) : NULL;
  dt_drawlayer_paint_stroke_t *stroke = ctx ? ctx->stroke : NULL;
  dt_drawlayer_worker_t *worker = ctx ? ctx->worker : NULL;
  if(IS_NULL_PTR(g) || IS_NULL_PTR(stroke) || IS_NULL_PTR(worker) || !stroke->pending_dabs || stroke->pending_dabs->len == 0) return 0;
  if(IS_NULL_PTR(g->process.base_patch.pixels) || g->process.base_patch.width <= 0 || g->process.base_patch.height <= 0)
    return 0;
 
  const guint min_batch = _worker_batch_min_size();
  const guint remaining_dabs = stroke->pending_dabs->len;
  const guint batch_dabs = (budget_us > 0)
                               ? MIN(remaining_dabs, min_batch * DRAWLAYER_OUTER_LIVE_BATCH_MULTIPLIER)
                               : remaining_dabs;
  if(batch_dabs == 0) return 0;
 
  dt_drawlayer_damaged_rect_t batch_bounds = { 0 };
  if(!_collect_batch_bounds(stroke->pending_dabs, batch_dabs, &g->process.base_patch, &batch_bounds))
  {
    g_array_remove_range(stroke->pending_dabs, 0, batch_dabs);
    return batch_dabs;
  }
  if(!_ensure_heartbeat_batch_buffers(worker, &batch_bounds)) return 0;
 
  dt_drawlayer_cache_patch_t *const heartbeat_patch = &worker->heartbeat_patch;
  dt_drawlayer_cache_patch_t *const heartbeat_mask = &worker->heartbeat_stroke_mask;
  dt_drawlayer_damaged_rect_t batch_damage = { 0 };
  guint processed_dabs = 0;
  gboolean used_outer_loop = FALSE;
  const double batch_t0 = dt_get_wtime();
 
  /* Build the heartbeat scratch patch from the latest committed layer state,
   * then keep the authoritative base patch read-locked while blur/smudge
   * sample from it during rasterization. */
  dt_drawlayer_cache_patch_rdlock(&g->process.base_patch);
  dt_drawlayer_cache_patch_rdlock(&g->process.stroke_mask);
  _copy_rgba_batch_from_locked_patch(&g->process.base_patch, heartbeat_patch);
  _copy_mask_batch_from_locked_patch(&g->process.stroke_mask, heartbeat_mask);
  /* Preferred path: one coverage accumulation, one composite. It is the whole batch or
   * nothing -- `dt_drawlayer_brush_batch_is_uniform` refuses a run whose dabs do not share
   * the mode, opacity, colour and flow the closed form is derived for, and the serial loop
   * below then handles every dab as before. */
  dt_drawlayer_brush_batch_t uniform_batch = { 0 };
  if(dt_drawlayer_brush_batch_is_uniform(&g_array_index(stroke->pending_dabs, dt_drawlayer_brush_dab_t, 0),
                                         batch_dabs, &uniform_batch)
     && !IS_NULL_PTR(worker->heartbeat_transmittance))
  {
    if(dt_drawlayer_brush_rasterize_batch(&uniform_batch, heartbeat_patch, 1.0f, heartbeat_mask,
                                          worker->heartbeat_transmittance, worker->heartbeat_noise,
                                          &batch_damage))
    {
      used_outer_loop = TRUE;
      processed_dabs = batch_dabs;
      _log_worker_batch_timing("batch", processed_dabs, _worker_batch_min_size(),
                               1000.0 * (dt_get_wtime() - batch_t0), TRUE);
      /* The batch path does not feed the 3-dab window, which exists solely so a SMUDGE dab can
       * see its predecessor. Clear it rather than leave a window with a hole in it: a following
       * SMUDGE dab then reads as the start of a run, which is the defined conservative state
       * (`previous_sample` NULL, pickup cleared). The tile-lock path had the same hole and left
       * it stale. */
      if(stroke->dab_window) g_array_set_size(stroke->dab_window, 0);
    }
  }
#if defined(_OPENMP) && OUTER_LOOP
  if(processed_dabs == 0 && batch_dabs >= min_batch
     && _dab_batch_supports_outer_loop(stroke->pending_dabs, batch_dabs))
  {
    used_outer_loop = TRUE;
    processed_dabs = _rasterize_dab_batch_outer_loop(stroke->pending_dabs, batch_dabs,
                                                     _clamp01(stroke->distance_percent),
                                                     &g->process.base_patch, heartbeat_patch, 1.0f,
                                                     heartbeat_mask, &batch_damage, "heartbeat");
  }
#endif
  while(processed_dabs < batch_dabs)
  {
    const dt_drawlayer_brush_dab_t *dab
        = &g_array_index(stroke->pending_dabs, dt_drawlayer_brush_dab_t, processed_dabs);
    _process_backend_dab(dab, ctx, &g->process.base_patch, heartbeat_patch, heartbeat_mask, &batch_damage);
    processed_dabs++;
 
    if(budget_us > 0)
    {
      const gint64 elapsed_us = (gint64)(1000000.0 * (dt_get_wtime() - batch_t0));
      if(processed_dabs >= min_batch && elapsed_us >= budget_us) break;
    }
  }
  dt_drawlayer_cache_patch_rdunlock(&g->process.stroke_mask);
  dt_drawlayer_cache_patch_rdunlock(&g->process.base_patch);
 
  if(processed_dabs == 0) return 0;
 
  const dt_drawlayer_brush_dab_t *last_dab
      = &g_array_index(stroke->pending_dabs, dt_drawlayer_brush_dab_t, processed_dabs - 1);
  g_array_remove_range(stroke->pending_dabs, 0, processed_dabs);
 
  if(batch_damage.valid)
  {
    dt_drawlayer_damaged_rect_t absolute_damage = { 0 };
    if(_translate_batch_damage(heartbeat_patch, &batch_damage, &absolute_damage))
    {
      dt_drawlayer_cache_patch_wrlock(&g->process.base_patch);
      dt_drawlayer_cache_patch_wrlock(&g->process.stroke_mask);
      _copy_rgba_damage_to_locked_patch(heartbeat_patch, &batch_damage, &g->process.base_patch);
      _copy_mask_damage_to_locked_patch(heartbeat_mask, &batch_damage, &g->process.stroke_mask);
      _clear_rgba_damage_in_patch(heartbeat_patch, &batch_damage);
      _clear_mask_damage_in_patch(heartbeat_mask, &batch_damage);
      dt_dev_pixelpipe_cache_flush_host_pinned_image(g->process.base_patch.pixels,
                                                     g->process.base_patch.cache_entry, -1);
 
      /* Publish the damage INSIDE the write-lock span that wrote the pixels it describes.
       * The pipeline reads and resets this rect under the base-patch READ lock (taken in
       * `_update_runtime_state`, released in `_release_runtime_source`), which is mutually
       * exclusive with this write lock -- so this was the one access of the three that sat
       * outside a lock. Published after the unlock, a pipeline read landing in the gap saw
       * pixels without the damage naming them, then cleared the rect: the window was
       * uploaded but composited against the wrong rectangle. */
      g->process.cache_dirty = TRUE;
      dt_drawlayer_paint_runtime_note_dab_damage(&g->process.cache_dirty_rect, &absolute_damage);
 
      dt_drawlayer_cache_patch_wrunlock(&g->process.stroke_mask);
      dt_drawlayer_cache_patch_wrunlock(&g->process.base_patch);
 
      dt_drawlayer_paint_runtime_note_dab_damage(worker->backend_path, &absolute_damage);
      dt_drawlayer_paint_runtime_note_dab_damage(&worker->live_publish_damage, &absolute_damage);
      g->stroke.last_dab_valid = TRUE;
      g->stroke.last_dab_x = last_dab->x;
      g->stroke.last_dab_y = last_dab->y;
    }
  }
 
  if(!used_outer_loop)
    _log_worker_batch_timing("heartbeat", processed_dabs, 1, 1000.0 * (dt_get_wtime() - batch_t0), FALSE);
  return processed_dabs;
}
 
static void _rt_queue_clear_locked(dt_drawlayer_worker_t *rt)
{
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  if(IS_NULL_PTR(worker)) return;
  worker->ring_head = 0;
  worker->ring_tail = 0;
  worker->ring_count = 0;
}
 
static gboolean _rt_queue_empty(const dt_drawlayer_worker_t *rt)
{
  const drawlayer_rt_worker_t *worker = _backend_worker_const(rt);
  return !worker || worker->ring_count == 0;
}
 
static gboolean _rt_queue_full(const dt_drawlayer_worker_t *rt)
{
  const drawlayer_rt_worker_t *worker = _backend_worker_const(rt);
  return !worker || (worker->ring_capacity > 0 && worker->ring_count >= worker->ring_capacity);
}
 
static gboolean _rt_queue_push_locked(dt_drawlayer_worker_t *rt,
                                      const dt_drawlayer_paint_raw_input_t *event)
{
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  if(IS_NULL_PTR(worker) || IS_NULL_PTR(event) || IS_NULL_PTR(worker->ring) || worker->ring_capacity == 0 || _rt_queue_full(rt)) return FALSE;
  worker->ring[worker->ring_tail] = *event;
  worker->ring_tail = (worker->ring_tail + 1) % worker->ring_capacity;
  worker->ring_count++;
  return TRUE;
}
 
static gboolean _rt_queue_pop_locked(dt_drawlayer_worker_t *rt,
                                     dt_drawlayer_paint_raw_input_t *event)
{
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  if(IS_NULL_PTR(worker) || IS_NULL_PTR(event) || IS_NULL_PTR(worker->ring) || worker->ring_capacity == 0 || _rt_queue_empty(rt)) return FALSE;
  *event = worker->ring[worker->ring_head];
  worker->ring_head = (worker->ring_head + 1) % worker->ring_capacity;
  worker->ring_count--;
  return TRUE;
}
 
static inline gboolean _worker_is_started(const drawlayer_rt_worker_t *worker)
{
  return worker && worker->thread_started;
}
 
static inline gboolean _worker_is_busy(const drawlayer_rt_worker_t *worker)
{
  return worker && worker->state == DT_DRAWLAYER_WORKER_STATE_BUSY;
}
 
static inline gboolean _worker_pause_requested(const drawlayer_rt_worker_t *worker)
{
  return worker
         && (worker->state == DT_DRAWLAYER_WORKER_STATE_PAUSING
             || worker->state == DT_DRAWLAYER_WORKER_STATE_PAUSED);
}
 
static inline gboolean _backend_pending_dabs_locked(const dt_drawlayer_worker_t *rt)
{
  return rt && rt->stroke && rt->stroke->pending_dabs && rt->stroke->pending_dabs->len > 0;
}
 
static void _rt_set_worker_state(dt_drawlayer_worker_t *rt, const dt_drawlayer_worker_state_t state)
{
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  if(!IS_NULL_PTR(worker)) worker->state = state;
}
 
static void _set_current_thread_realtime_best_effort(void)
{
#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
  struct sched_param param = { 0 };
  const int max_prio = sched_get_priority_max(SCHED_FIFO);
  if(max_prio > 0)
  {
    param.sched_priority = MIN(max_prio, 80);
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);
  }
#endif
}
 
static gboolean _workers_active_locked(const dt_drawlayer_worker_t *rt)
{
  const drawlayer_rt_worker_t *worker = _backend_worker_const(rt);
  return worker && (_worker_is_busy(worker) || worker->ring_count > 0
                    || _backend_pending_dabs_locked(rt)
                    || (rt->finish_commit_pending && *rt->finish_commit_pending));
}
 
static gboolean _workers_any_active_locked(const dt_drawlayer_worker_t *rt)
{
  return _workers_active_locked(rt);
}
 
static gboolean _workers_ready_for_commit_locked(const dt_drawlayer_worker_t *rt)
{
  const drawlayer_rt_worker_t *worker = _backend_worker_const(rt);
  return worker && rt->finish_commit_pending && rt->painting
         && *rt->finish_commit_pending && !*rt->painting
         && !_worker_is_busy(worker) && worker->ring_count == 0
         && !_backend_pending_dabs_locked(rt);
}
 
static gboolean _rt_workers_active(dt_drawlayer_worker_t *rt)
{
  gboolean active = FALSE;
  if(IS_NULL_PTR(rt)) return FALSE;
  dt_pthread_mutex_lock(&rt->worker_mutex);
  active = _workers_active_locked(rt);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
  return active;
}
 
static gboolean _rt_workers_any_active(dt_drawlayer_worker_t *rt)
{
  gboolean active = FALSE;
  if(IS_NULL_PTR(rt)) return FALSE;
  dt_pthread_mutex_lock(&rt->worker_mutex);
  active = _workers_any_active_locked(rt);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
  return active;
}
 
static gboolean _commit_dabs_on_gui_thread(gpointer user_data)
{
  dt_iop_module_t *self = (dt_iop_module_t *)user_data;
  dt_iop_drawlayer_gui_data_t *g = IS_NULL_PTR(self) ? NULL : (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self);
  dt_drawlayer_worker_t *rt = IS_NULL_PTR(g) ? NULL : g->stroke.worker;
  if(IS_NULL_PTR(rt)) return G_SOURCE_REMOVE;
 
  /* Clear the in-flight marker before committing, so a commit that re-arms the request
   * can post a fresh one. Both this callback and `_cancel_pending_gui_commit` run on the
   * GUI thread, so the source can never be removed while it is dispatching. */
  dt_pthread_mutex_lock(&rt->worker_mutex);
  rt->commit_idle_id = 0;
  dt_pthread_mutex_unlock(&rt->worker_mutex);
 
  dt_drawlayer_commit_dabs(self, TRUE);
  return G_SOURCE_REMOVE;
}
 
static void _cancel_pending_gui_commit(dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return;
  dt_pthread_mutex_lock(&rt->worker_mutex);
  const guint source_id = rt->commit_idle_id;
  rt->commit_idle_id = 0;
  dt_pthread_mutex_unlock(&rt->worker_mutex);
  if(source_id) g_source_remove(source_id);
}
 
static void _backend_worker_on_idle(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  dt_iop_drawlayer_gui_data_t *g = self ? (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self) : NULL;
  drawlayer_paint_backend_ctx_t ctx = _make_backend_ctx(self, rt, rt ? rt->stroke : NULL);
  if(!IS_NULL_PTR(self) && g && !IS_NULL_PTR(rt) && rt->stroke && rt->stroke->pending_dabs && rt->stroke->pending_dabs->len > 0)
  {
    /* Once a stroke has emitted dabs, keep draining the heartbeat backlog in
     * this same idle phase instead of returning to the outer loop after each
     * batch. Otherwise long strokes can momentarily "stall" between batches as
     * the worker bounces through the queue/idle state machine waiting for the
     * next loop turn. */
    while(rt->stroke && rt->stroke->pending_dabs && rt->stroke->pending_dabs->len > 0)
    {
      guint processed_dabs = 0;
      dt_pthread_mutex_lock(&rt->worker_mutex);
      const gboolean should_stop = _worker_pause_requested(_backend_worker_const(rt))
                                   || _backend_worker_const(rt)->stop;
      dt_pthread_mutex_unlock(&rt->worker_mutex);
      if(should_stop) break;
 
      const gint64 interval_us = _live_publish_interval_us();
      processed_dabs = _rasterize_pending_dab_batch(&ctx, interval_us);
      if(processed_dabs == 0) break;
 
      /* Honour the same deadline the input path honours. This loop is where most dabs of a
       * fast drag are processed, and it used to publish after EVERY batch: a transient-params
       * write, a TOP_CHANGED flag and a `dt_control_queue_redraw_center()` -- the last an
       * asynchronous signal raise, so a malloc, a calloc and a GLib idle source each time --
       * at up to one per 2 x nthreads dabs. The darkroom loop was dropping the surplus anyway,
       * so the frames the user sees are unchanged; what goes away is the flooding.
       * `live_publish_damage` is unioned across batches (see `_rasterize_pending_dab_batch`),
       * so a skipped publish loses no coverage -- the next one carries it. */
      if(_live_publish_deadline_reached(rt, g_get_monotonic_time(), interval_us))
        _publish_backend_progress(&ctx, TRUE);
    }
 
    /* The last batch of a drain must reach the screen -- but ONLY once the stroke is over.
     * This hook runs on every idle transition, which during a live stroke is once per input
     * batch, so publishing here unconditionally defeated the deadline above entirely: measured
     * on a 10.4 s stroke, 434 publishes at a 19 ms median gap against a main pipe that needed
     * 109 ms a frame and delivered 75. The surplus is not free -- each publish raises a centre
     * redraw, and the GUI thread was compositing the window 48 times a second to show 9 new
     * frames, on the same thread that has to service the pointer.
     * Mid-stroke, skipping loses nothing: `live_publish_damage` accumulates and the next
     * publish carries it. After the stroke, this is the path that shows the final dabs before
     * the commit lands. */
    if(rt->painting && !*rt->painting)
      _publish_backend_progress(&ctx, TRUE);
  }
 
  if(IS_NULL_PTR(rt)) return;
  /* Decide and post under the SAME lock acquisition. The old code read the predicate, dropped
   * the lock, then committed — and a GUI push landing in that window made the commit's
   * `dt_drawlayer_worker_wait_idle` wait on a ring only this thread drains. */
  dt_pthread_mutex_lock(&rt->worker_mutex);
  if(_workers_ready_for_commit_locked(rt) && rt->commit_idle_id == 0)
    rt->commit_idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE, _commit_dabs_on_gui_thread, self, NULL);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
}
 
static void _backend_worker_process_sample(dt_iop_module_t *self, dt_drawlayer_worker_t *rt,
                                           const dt_drawlayer_paint_raw_input_t *input)
{
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(input)) return;
  if(!IS_NULL_PTR(rt) && !IS_NULL_PTR(input) && input->stroke_pos == DT_DRAWLAYER_PAINT_STROKE_FIRST)
  {
    _stroke_begin(rt);
  }
 
  if(!rt->stroke && !_stroke_begin(rt)) return;
  if(rt->stroke_raw_inputs) g_array_append_val(rt->stroke_raw_inputs, *input);
  _process_backend_input(self, input, rt->stroke);
}
 
static void _backend_worker_process_stroke_end(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return;
 
  /* Stroke end only finalizes path generation and asks for commit. Pending dabs
   * still drain through the same heartbeat batches as live painting, so the
   * worker keeps alternating raster and pipeline refresh until the stroke is
   * fully materialized. */
  if(rt->stroke)
  {
    dt_drawlayer_paint_finalize_path(rt->stroke);
  }
  dt_pthread_mutex_lock(&rt->worker_mutex);
  if(rt->finish_commit_pending) *rt->finish_commit_pending = TRUE;
  pthread_cond_broadcast(&rt->worker_cond);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
}
 
static const drawlayer_rt_callbacks_t _rt_callbacks[] = {
  [DRAWLAYER_RT_WORKER_BACKEND] = {
    .thread_name = "draw-back",
    .process_sample = _backend_worker_process_sample,
    .process_stroke_end = _backend_worker_process_stroke_end,
    .on_idle = _backend_worker_on_idle,
  },
};
 
static void _rt_destroy_state(dt_iop_module_t *self, dt_drawlayer_worker_t **rt_out)
{
  if(IS_NULL_PTR(rt_out) || !*rt_out) return;
  dt_drawlayer_worker_t *rt = *rt_out;
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  _stop_worker(self ? self : rt->self, rt);
  _stroke_destroy(rt);
  if(rt->backend_history) g_array_free(rt->backend_history, TRUE);
  if(rt->stroke_raw_inputs) g_array_free(rt->stroke_raw_inputs, TRUE);
  dt_drawlayer_paint_runtime_state_destroy(&rt->backend_path);
  dt_drawlayer_cache_patch_clear(&rt->heartbeat_patch, DRAWLAYER_HEARTBEAT_PATCH_NAME);
  dt_drawlayer_cache_patch_clear(&rt->heartbeat_stroke_mask, DRAWLAYER_HEARTBEAT_MASK_NAME);
  g_free(rt->heartbeat_transmittance);
  rt->heartbeat_transmittance = NULL;
  g_free(rt->heartbeat_noise);
  rt->heartbeat_noise = NULL;
  rt->heartbeat_transmittance_capacity = 0;
  dt_free(worker->ring);
  pthread_cond_destroy(&rt->worker_cond);
  dt_pthread_mutex_destroy(&rt->worker_mutex);
  dt_free(rt);
  *rt_out = NULL;
}
 
static void _rt_init_state(dt_iop_module_t *self, dt_drawlayer_worker_t **rt_out,
                           gboolean *painting, gboolean *finish_commit_pending,
                           guint *stroke_sample_count, uint32_t *current_stroke_batch)
{
  if(IS_NULL_PTR(rt_out)) return;
  _rt_destroy_state(self, rt_out);
  dt_drawlayer_worker_t *rt = NULL;
  rt = g_malloc0(sizeof(*rt));
  *rt_out = rt;
  if(IS_NULL_PTR(rt)) return;
 
  rt->self = self;
  rt->painting = painting;
  rt->finish_commit_pending = finish_commit_pending;
  rt->stroke_sample_count = stroke_sample_count;
  rt->current_stroke_batch = current_stroke_batch;
  rt->backend_path = dt_drawlayer_paint_runtime_state_create();
  dt_pthread_mutex_init(&rt->worker_mutex, NULL);
  pthread_cond_init(&rt->worker_cond, NULL);
 
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  worker->ring_capacity = DRAWLAYER_WORKER_RING_CAPACITY;
  worker->ring = g_malloc_n(worker->ring_capacity, sizeof(dt_drawlayer_paint_raw_input_t));
  rt->backend_history = g_array_new(FALSE, FALSE, sizeof(dt_drawlayer_brush_dab_t));
  rt->stroke_raw_inputs = g_array_new(FALSE, FALSE, sizeof(dt_drawlayer_paint_raw_input_t));
  _reset_live_publish(rt);
  _stroke_create(rt);
}
 
static void _rt_cleanup_state(dt_drawlayer_worker_t **rt_out)
{
  _rt_destroy_state(NULL, rt_out);
}
 
gboolean dt_drawlayer_worker_wait_idle(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  (void)self;
  const drawlayer_rt_worker_t *worker = _backend_worker_const(rt);
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(worker) || !_worker_is_started(worker)) return TRUE;
 
  /* TRIPWIRE. This must only ever be called from the GUI thread. The ring's only consumer is
   * the worker itself, so waiting here from the worker parks it forever, and `_stop_worker` —
   * whose `stop` flag is the sole escape — calls this first, so the GUI thread then hangs on
   * the same predicate. Do NOT "fix" a hit by returning early: at that point the ring may hold
   * a new stroke's events, and committing would wipe that stroke's session state instead.
   * Post the commit to the GUI thread (`_commit_dabs_on_gui_thread`) as `_backend_worker_on_idle`
   * does. */
  if(worker->thread_started && pthread_equal(pthread_self(), worker->thread))
    dt_print(DT_DEBUG_ALWAYS,
             "[drawlayer] BUG: dt_drawlayer_worker_wait_idle called on the worker thread — it consumes the "
             "ring it is about to wait on, and will deadlock with the GUI thread.\n");
 
  dt_pthread_mutex_lock(&rt->worker_mutex);
  while(_worker_is_busy(worker) || worker->ring_count > 0)
  {
    if(worker->stop) break;
    dt_pthread_cond_wait(&rt->worker_cond, &rt->worker_mutex);
  }
  dt_pthread_mutex_unlock(&rt->worker_mutex);
  return TRUE;
}
 
typedef struct drawlayer_rt_thread_ctx_t
{
  dt_drawlayer_worker_t *rt;
} drawlayer_rt_thread_ctx_t;
 
static void *_drawlayer_worker_main(void *user_data)
{
  drawlayer_rt_thread_ctx_t *ctx = (drawlayer_rt_thread_ctx_t *)user_data;
  dt_drawlayer_worker_t *rt = ctx ? ctx->rt : NULL;
  dt_free(ctx);
 
  dt_iop_module_t *self = rt ? rt->self : NULL;
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  const drawlayer_rt_callbacks_t *cb = &_rt_callbacks[DRAWLAYER_RT_WORKER_BACKEND];
  if(IS_NULL_PTR(self) || IS_NULL_PTR(rt) || IS_NULL_PTR(worker) || IS_NULL_PTR(cb)) return NULL;
 
  dt_pthread_setname(cb->thread_name);
  _set_current_thread_realtime_best_effort();
 
  while(TRUE)
  {
    dt_drawlayer_paint_raw_input_t event = { 0 };
    gboolean have_event = FALSE;
    gboolean have_backlog = FALSE;
 
    dt_pthread_mutex_lock(&rt->worker_mutex);
    while(!worker->stop && (_worker_pause_requested(worker)
                            || (worker->ring_count == 0 && !_backend_pending_dabs_locked(rt))))
    {
      _rt_set_worker_state(rt, _worker_pause_requested(worker) ? DT_DRAWLAYER_WORKER_STATE_PAUSED
                                                               : DT_DRAWLAYER_WORKER_STATE_IDLE);
      pthread_cond_broadcast(&rt->worker_cond);
      dt_pthread_mutex_unlock(&rt->worker_mutex);
      if(cb->on_idle) cb->on_idle(self, rt);
      dt_pthread_mutex_lock(&rt->worker_mutex);
      if(!worker->stop && (_worker_pause_requested(worker)
                           || (worker->ring_count == 0 && !_backend_pending_dabs_locked(rt))))
        dt_pthread_cond_wait(&rt->worker_cond, &rt->worker_mutex);
    }
 
    if(worker->stop)
    {
      _rt_set_worker_state(rt, DT_DRAWLAYER_WORKER_STATE_STOPPED);
      pthread_cond_broadcast(&rt->worker_cond);
      dt_pthread_mutex_unlock(&rt->worker_mutex);
      break;
    }
 
    have_backlog = _backend_pending_dabs_locked(rt);
    have_event = _rt_queue_pop_locked(rt, &event);
    _rt_set_worker_state(rt, (have_event || have_backlog) ? DT_DRAWLAYER_WORKER_STATE_BUSY
                                                          : DT_DRAWLAYER_WORKER_STATE_IDLE);
    dt_pthread_mutex_unlock(&rt->worker_mutex);
 
    if(!have_event)
    {
      if(cb->on_idle) cb->on_idle(self, rt);
      continue;
    }
 
    if(event.stroke_pos == DT_DRAWLAYER_PAINT_STROKE_END)
    {
      /* If stroke-end carries a real raw sample (button release), process it
       * before closing the stroke so the final segment is not lost. */
      if(cb->process_sample && event.event_ts != 0)
        cb->process_sample(self, rt, &event);
      if(cb->process_stroke_end) cb->process_stroke_end(self, rt);
    }
    else
    {
      if(cb->process_sample) cb->process_sample(self, rt, &event);
    }
 
    dt_pthread_mutex_lock(&rt->worker_mutex);
    have_backlog = _backend_pending_dabs_locked(rt);
    _rt_set_worker_state(rt, _worker_pause_requested(worker) ? DT_DRAWLAYER_WORKER_STATE_PAUSED
                                                             : (have_backlog ? DT_DRAWLAYER_WORKER_STATE_BUSY
                                                                             : DT_DRAWLAYER_WORKER_STATE_IDLE));
    pthread_cond_broadcast(&rt->worker_cond);
    dt_pthread_mutex_unlock(&rt->worker_mutex);
    if(cb->on_idle) cb->on_idle(self, rt);
  }
 
  return NULL;
}
 
static gboolean _start_worker(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  if(IS_NULL_PTR(self) || IS_NULL_PTR(rt) || IS_NULL_PTR(worker)) return FALSE;
  if(_worker_is_started(worker))
    return TRUE;
 
  worker->stop = FALSE;
  worker->state = DT_DRAWLAYER_WORKER_STATE_STOPPED;
 
  drawlayer_rt_thread_ctx_t *ctx = g_malloc(sizeof(*ctx));
  if(IS_NULL_PTR(ctx)) return FALSE;
  ctx->rt = rt;
 
  const int err = dt_pthread_create(&worker->thread, _drawlayer_worker_main, ctx, TRUE);
  if(err != 0)
  {
    dt_free(ctx);
    worker->thread_started = FALSE;
    worker->state = DT_DRAWLAYER_WORKER_STATE_STOPPED;
    return FALSE;
  }
 
  worker->thread_started = TRUE;
  worker->state = DT_DRAWLAYER_WORKER_STATE_IDLE;
  return TRUE;
}
 
void dt_drawlayer_worker_cancel_async_commit(dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return;
 
  dt_pthread_mutex_lock(&rt->worker_mutex);
  if(rt->finish_commit_pending) *rt->finish_commit_pending = FALSE;
  dt_pthread_mutex_unlock(&rt->worker_mutex);
}
 
static void _stop_worker(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  if(IS_NULL_PTR(rt)) return;
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  dt_drawlayer_worker_cancel_async_commit(rt);
  /* Before joining: a commit the worker posted must not fire against a torn-down module.
   * This runs on the GUI thread, as does the callback, so once the source is removed here
   * no commit can be in flight. */
  _cancel_pending_gui_commit(rt);
 
  if(worker && _worker_is_started(worker))
  {
    dt_drawlayer_worker_wait_idle(self, rt);
 
    dt_pthread_mutex_lock(&rt->worker_mutex);
    worker->stop = TRUE;
    pthread_cond_broadcast(&rt->worker_cond);
    dt_pthread_mutex_unlock(&rt->worker_mutex);
 
    pthread_join(worker->thread, NULL);
    memset(&worker->thread, 0, sizeof(worker->thread));
    worker->thread_started = FALSE;
    worker->state = DT_DRAWLAYER_WORKER_STATE_STOPPED;
    worker->stop = FALSE;
    _rt_queue_clear_locked(rt);
    _stroke_clear(rt);
  }
}
 
void dt_drawlayer_worker_pause(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  (void)self;
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(worker) || !_worker_is_started(worker)) return;
 
  dt_pthread_mutex_lock(&rt->worker_mutex);
  worker->state = _worker_is_busy(worker) ? DT_DRAWLAYER_WORKER_STATE_PAUSING
                                          : DT_DRAWLAYER_WORKER_STATE_PAUSED;
  while(_worker_is_busy(worker) && !worker->stop)
    dt_pthread_cond_wait(&rt->worker_cond, &rt->worker_mutex);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
}
 
void dt_drawlayer_worker_resume(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  (void)self;
  drawlayer_rt_worker_t *worker = _backend_worker(rt);
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(worker) || !_worker_is_started(worker)) return;
 
  dt_pthread_mutex_lock(&rt->worker_mutex);
  worker->state = DT_DRAWLAYER_WORKER_STATE_IDLE;
  pthread_cond_broadcast(&rt->worker_cond);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
}
 
static gboolean _enqueue_event(dt_iop_module_t *self, dt_drawlayer_worker_t *rt,
                               const dt_drawlayer_paint_raw_input_t *event)
{
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(event)) return FALSE;
  if(!_start_worker(self, rt)) return FALSE;
 
  dt_pthread_mutex_lock(&rt->worker_mutex);
  const gboolean ok = _rt_queue_push_locked(rt, event);
  pthread_cond_broadcast(&rt->worker_cond);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
  return ok;
}
 
static gboolean _enqueue_input(dt_iop_module_t *self, dt_drawlayer_worker_t *rt,
                               const dt_drawlayer_paint_raw_input_t *input)
{
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(input)) return FALSE;
  if(!_start_worker(self, rt)) return FALSE;
 
  const dt_drawlayer_paint_raw_input_t event = *input;
 
  gboolean ok = FALSE;
  dt_pthread_mutex_lock(&rt->worker_mutex);
  if(!_rt_queue_full(rt))
  {
    ok = _rt_queue_push_locked(rt, &event);
    if(ok && rt->stroke_sample_count) (*rt->stroke_sample_count)++;
  }
  if(!ok)
  {
    /* Saturated queue policy: abort current stroke deterministically instead of
     * silently dropping or coalescing raw input events. Keep FIFO backlog and
     * force a stroke end at the newest queued slot. */
    drawlayer_rt_worker_t *worker = _backend_worker(rt);
    dt_drawlayer_paint_raw_input_t end_input = *input;
    end_input.stroke_pos = DT_DRAWLAYER_PAINT_STROKE_END;
    end_input.event_index = input->event_index + 1u;
    const dt_drawlayer_paint_raw_input_t end_event = end_input;
    if(worker->ring && worker->ring_count > 0)
    {
      const guint last_index = (worker->ring_tail + worker->ring_capacity - 1) % worker->ring_capacity;
      worker->ring[last_index] = end_event;
      ok = TRUE;
    }
    else
      ok = _rt_queue_push_locked(rt, &end_event);
 
    if(rt->finish_commit_pending) *rt->finish_commit_pending = TRUE;
    dt_control_alert(_("Drawing not saved"), _("drawing worker queue is full, stroke aborted"), NULL);
  }
  pthread_cond_broadcast(&rt->worker_cond);
  dt_pthread_mutex_unlock(&rt->worker_mutex);
  return ok;
}
 
static gboolean _enqueue_stroke_end(dt_iop_module_t *self, dt_drawlayer_worker_t *rt,
                                    const dt_drawlayer_paint_raw_input_t *input)
{
  if(IS_NULL_PTR(rt)) return FALSE;
 
  dt_drawlayer_paint_raw_input_t end_input = { 0 };
  if(input) end_input = *input;
  if(end_input.stroke_batch == 0u && rt->current_stroke_batch)
    end_input.stroke_batch = *rt->current_stroke_batch;
  end_input.stroke_pos = DT_DRAWLAYER_PAINT_STROKE_END;
 
  if(_enqueue_event(self, rt, &end_input)) return TRUE;
  dt_control_log(_("drawing worker queue is full"));
  return FALSE;
}
 
void dt_drawlayer_worker_init(dt_iop_module_t *self, dt_drawlayer_worker_t **worker,
                              gboolean *painting, gboolean *finish_commit_pending,
                              guint *stroke_sample_count, uint32_t *current_stroke_batch)
{
  _rt_init_state(self, worker, painting, finish_commit_pending, stroke_sample_count, current_stroke_batch);
}
 
void dt_drawlayer_worker_cleanup(dt_drawlayer_worker_t **worker)
{
  _rt_cleanup_state(worker);
}
 
gboolean dt_drawlayer_worker_active(const dt_drawlayer_worker_t *worker)
{
  return _rt_workers_active((dt_drawlayer_worker_t *)worker);
}
 
gboolean dt_drawlayer_worker_any_active(const dt_drawlayer_worker_t *worker)
{
  return _rt_workers_any_active((dt_drawlayer_worker_t *)worker);
}
 
gboolean dt_drawlayer_worker_ensure_running(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  return _start_worker(self, rt);
}
 
void dt_drawlayer_worker_stop(dt_iop_module_t *self, dt_drawlayer_worker_t *rt)
{
  _stop_worker(self, rt);
}
 
void dt_drawlayer_worker_get_snapshot(const dt_drawlayer_worker_t *worker,
                                      dt_drawlayer_worker_snapshot_t *snapshot)
{
  if(snapshot) *snapshot = (dt_drawlayer_worker_snapshot_t){ 0 };
  dt_drawlayer_worker_t *rt = (dt_drawlayer_worker_t *)worker;
  if(IS_NULL_PTR(rt) || IS_NULL_PTR(snapshot)) return;
 
  dt_pthread_mutex_lock(&rt->worker_mutex);
  const drawlayer_rt_worker_t *backend = _backend_worker_const(rt);
  snapshot->backend_state = backend->state;
  snapshot->backend_queue_count = backend->ring_count;
  snapshot->commit_pending = rt->finish_commit_pending && *rt->finish_commit_pending;
  dt_pthread_mutex_unlock(&rt->worker_mutex);
}
 
void dt_drawlayer_worker_request_commit(dt_drawlayer_worker_t *worker)
{
  if(IS_NULL_PTR(worker)) return;
  dt_pthread_mutex_lock(&worker->worker_mutex);
  if(worker->finish_commit_pending) *worker->finish_commit_pending = TRUE;
  pthread_cond_broadcast(&worker->worker_cond);
  dt_pthread_mutex_unlock(&worker->worker_mutex);
}
 
void dt_drawlayer_worker_snapshot_params(dt_drawlayer_worker_t *worker,
                                         const dt_iop_drawlayer_params_t *params)
{
  if(IS_NULL_PTR(worker) || IS_NULL_PTR(params)) return;
  dt_pthread_mutex_lock(&worker->worker_mutex);
  worker->publish_params = *params;
  dt_pthread_mutex_unlock(&worker->worker_mutex);
}
 
void dt_drawlayer_worker_seal_for_commit(dt_drawlayer_worker_t *worker)
{
  (void)worker;
}
 
void dt_drawlayer_worker_reset_backend_path(dt_drawlayer_worker_t *worker)
{
  if(IS_NULL_PTR(worker)) return;
  dt_pthread_mutex_lock(&worker->worker_mutex);
  _reset_backend_path(worker);
  dt_pthread_mutex_unlock(&worker->worker_mutex);
}
 
void dt_drawlayer_worker_reset_live_publish(dt_drawlayer_worker_t *worker)
{
  if(IS_NULL_PTR(worker)) return;
  dt_pthread_mutex_lock(&worker->worker_mutex);
  _reset_live_publish(worker);
  dt_pthread_mutex_unlock(&worker->worker_mutex);
}
 
void dt_drawlayer_worker_reset_stroke(dt_drawlayer_worker_t *worker)
{
  if(IS_NULL_PTR(worker)) return;
  dt_pthread_mutex_lock(&worker->worker_mutex);
  _stroke_clear(worker);
  _reset_live_publish(worker);
  dt_pthread_mutex_unlock(&worker->worker_mutex);
}
 
GArray *dt_drawlayer_worker_raw_inputs(dt_drawlayer_worker_t *worker)
{
  return worker ? worker->stroke_raw_inputs : NULL;
}
 
gboolean dt_drawlayer_worker_enqueue_input(dt_drawlayer_worker_t *worker,
                                           const dt_drawlayer_paint_raw_input_t *input)
{
  return _enqueue_input(worker ? worker->self : NULL, worker, (const dt_drawlayer_paint_raw_input_t *)input);
}
 
gboolean dt_drawlayer_worker_enqueue_stroke_end(dt_drawlayer_worker_t *worker,
                                                const dt_drawlayer_paint_raw_input_t *input)
{
  return _enqueue_stroke_end(worker ? worker->self : NULL, worker, input);
}