layers.c

Go to the documentation of this file.

#include "iop/drawlayer/layers.h"
 
#include "iop/drawlayer/cache.h"       // dt_drawlayer_cache_patch_*()
#include "iop/drawlayer/io.h"          // dt_drawlayer_io_*()
#include "iop/drawlayer/runtime.h"     // dt_iop_drawlayer_gui_data_t (dereferenced here)
#include "iop/drawlayer/worker.h"      // dt_drawlayer_worker_*()
 
#include "control/user_message.h"    // dt_control_log()
#include "develop/develop.h"           // dt_dev_geometry_snapshot(), dt_dev_viewport_*()
#include "develop/dev_history.h"       // dt_dev_transient_params_clear()
#include "develop/imageop_gui.h"       // dt_iop_gui_data()
#include "develop/pixelpipe_hb.h"      // dt_dev_pixelpipe_resync_history_main()
#include "widgets/bauhaus.h"           // dt_bauhaus_combobox_*()
#include "widgets/widget_settings.h"   // dt_gui_widget_freeze()
 
typedef struct drawlayer_layer_cache_key_t
{
  int32_t imgid;
  int layer_width;
  int layer_height;
  const char *layer_name;
  int layer_order;
} drawlayer_layer_cache_key_t;
 
void dt_drawlayer_layers_append_error(GString *errors, const char *message)
{
  if(IS_NULL_PTR(errors) || IS_NULL_PTR(message) || message[0] == '\0') return;
  if(errors->len > 0) g_string_append(errors, "; ");
  g_string_append(errors, message);
}
 
void dt_drawlayer_layers_log_errors(GString *errors)
{
  if(IS_NULL_PTR(errors)) return;
  if(errors->len > 0) dt_control_log("%s", errors->str);
}
 
void dt_drawlayer_layers_populate_list(dt_iop_module_t *self)
{
  dt_iop_drawlayer_gui_data_t *g = (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_drawlayer_params_t *params = (dt_iop_drawlayer_params_t *)self->params;
  if(IS_NULL_PTR(g)) return;
  // Scope guard: the freeze spans the rest of the function, which has an early return; the
  // guard releases it on every exit path (no manual end-before-return needed).
  dt_gui_widget_freeze();
 
  while(dt_bauhaus_combobox_length(g->controls.layer_select) > 0)
    dt_bauhaus_combobox_remove_at(g->controls.layer_select, dt_bauhaus_combobox_length(g->controls.layer_select) - 1);
 
  if(IS_NULL_PTR(self->dev))
  {
    dt_bauhaus_combobox_set(g->controls.layer_select, -1);
    return;
  }
 
  char path[DT_PATH_MAX] = { 0 };
  char **names = NULL;
  int count = 0;
  if(dt_drawlayer_io_sidecar_path(self->dev->image_storage.id, path, sizeof(path)))
    dt_drawlayer_io_list_layer_names(path, &names, &count);
 
  int active = -1;
  const int listed_count = count;
  for(int i = 0; i < count; i++)
  {
    const char *page_name = names[i] ? names[i] : "";
    dt_bauhaus_combobox_add(g->controls.layer_select, page_name);
    if(params->layer_order == i || (params->layer_name[0] && !g_strcmp0(page_name, params->layer_name)))
      active = i;
  }
 
  dt_drawlayer_io_free_layer_names(&names, &count);
  if(active >= 0)
    dt_bauhaus_combobox_set(g->controls.layer_select, active);
  else if(listed_count > 0 && !dt_drawlayer_layer_name_non_empty(params->layer_name))
    dt_bauhaus_combobox_set(g->controls.layer_select, 0);
  else
    /* The combobox is reserved for layers that already exist in the TIFF
     * sidecar. Keep unsaved or missing module attachments out of the shared
     * list so switching layers never invents phantom entries. */
    dt_bauhaus_combobox_set(g->controls.layer_select, -1);
}
 
void dt_drawlayer_layers_reset_stroke_session(dt_iop_drawlayer_gui_data_t *g)
{
  if(IS_NULL_PTR(g)) return;
  g->stroke.stroke_sample_count = 0;
  g->stroke.stroke_event_index = 0;
  g->stroke.last_dab_valid = FALSE;
  dt_drawlayer_process_state_reset_stroke(&g->process);
  dt_drawlayer_worker_reset_backend_path(g->stroke.worker);
  dt_drawlayer_worker_reset_live_publish(g->stroke.worker);
}
 
static gboolean _layer_cache_matches(const dt_iop_drawlayer_gui_data_t *g, const drawlayer_layer_cache_key_t *key)
{
  /* Cache identity belongs to the module orchestration layer because it
   * combines sidecar identity with GUI/module state (active image, selected
   * layer, in-memory patch ownership). The low-level TIFF primitives stay in
   * drawlayer/io.c. */
  if(IS_NULL_PTR(g) || IS_NULL_PTR(key) || !g->process.cache_valid || IS_NULL_PTR(g->process.base_patch.pixels)) return FALSE;
  if(g->process.cache_imgid != key->imgid || g->process.base_patch.width != key->layer_width
     || g->process.base_patch.height != key->layer_height)
    return FALSE;
 
  /* Once a layer is cached in memory, `process()` should treat that payload as
   * authoritative until we explicitly reload or flush it. The page index in the
   * params is only a sidecar lookup hint and may legitimately drift after sidecar
   * rewrites or page reordering. Layer names are unique and stable by design, so
   * prefer them for cache identity. Falling back to the page index here causes
   * `process()` to re-open the TIFF and re-scan directories even though the
   * correct pixels are already in memory. */
  const char *target_name = key->layer_name ? key->layer_name : "";
  if(target_name[0] != '\0' || g->process.cache_layer_name[0] != '\0') return !g_strcmp0(g->process.cache_layer_name, target_name);
 
  if(key->layer_order >= 0 && g->process.cache_layer_order >= 0)
    return g->process.cache_layer_order == key->layer_order;
  return TRUE;
}
 
gboolean dt_drawlayer_ensure_layer_cache(dt_iop_module_t *self)
{
  /* Make sure `base_patch` mirrors the currently selected sidecar layer.
   * The low-level TIFF read/write primitives live in drawlayer/io.c, while this
   * function stays here because it orchestrates cache lifetime, widget state,
   * prompting, and history/UI side effects around those I/O operations. */
  dt_iop_drawlayer_gui_data_t *g = (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_drawlayer_params_t *params = (dt_iop_drawlayer_params_t *)self->params;
  if(IS_NULL_PTR(g) || IS_NULL_PTR(self->dev)) return FALSE;
 
  dt_drawlayer_sanitize_params(self, params);
  int layer_width = 0;
  int layer_height = 0;
  const int32_t imgid = self->dev->image_storage.id;
  GMainContext *const ui_ctx = g_main_context_default();
  const gboolean ui_thread = ui_ctx && g_main_context_is_owner(ui_ctx);
  if(!dt_drawlayer_resolve_layer_geometry(self, NULL, NULL, &layer_width, &layer_height, NULL, NULL))
  {
    const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(self->dev);
    layer_width = geometry.raw_width;
    layer_height = geometry.raw_height;
  }
  if(imgid <= 0 || layer_width <= 0 || layer_height <= 0) return FALSE;
  if(!dt_drawlayer_layer_name_non_empty(params->layer_name))
  {
    dt_drawlayer_release_all_base_patch_extra_refs(g);
    dt_drawlayer_cache_patch_clear(&g->process.base_patch, "drawlayer patch");
    g->process.cache_valid = FALSE;
    g->process.cache_dirty = FALSE;
    dt_drawlayer_paint_runtime_state_reset(&g->process.cache_dirty_rect);
    g->process.cache_imgid = -1;
    g->process.cache_layer_name[0] = '\0';
    g->process.cache_layer_order = -1;
    dt_drawlayer_process_state_invalidate(&g->process);
    if(ui_thread) dt_drawlayer_refresh_layer_widgets(self);
    return TRUE;
  }
  const drawlayer_layer_cache_key_t cache_key = {
    .imgid = imgid,
    .layer_width = layer_width,
    .layer_height = layer_height,
    .layer_name = params->layer_name,
    .layer_order = params->layer_order,
  };
 
  GString *errors = g_string_new(NULL);
 
  char current_profile[DRAWLAYER_PROFILE_SIZE] = { 0 };
  const gboolean have_current_profile = dt_drawlayer_current_work_profile_key(self, self->dev->iop, self->dev->pipe,
                                                                      current_profile, sizeof(current_profile));
  if(!have_current_profile)
    dt_drawlayer_layers_append_error(errors, _("failed to resolve drawlayer working profile"));
  else if(params->work_profile[0] == '\0')
    g_strlcpy(params->work_profile, current_profile, sizeof(params->work_profile));
  else if(g_strcmp0(params->work_profile, current_profile))
    dt_drawlayer_layers_append_error(errors, _("drawlayer working profile mismatch"));
 
  if(_layer_cache_matches(g, &cache_key))
  {
    dt_drawlayer_layers_log_errors(errors);
    g_string_free(errors, TRUE);
    return TRUE;
  }
 
  if(!dt_drawlayer_flush_layer_cache(self))
  {
    dt_drawlayer_layers_append_error(errors, _("failed to write drawing layer sidecar"));
    dt_drawlayer_layers_log_errors(errors);
    g_string_free(errors, TRUE);
    return FALSE;
  }
  /* We are about to replace/rebind `g->process.base_patch`; drop all explicit extra
   * refs from the previous entry first so counters never leak across entries. */
  dt_drawlayer_release_all_base_patch_extra_refs(g);
 
  int created = 0;
  if(!dt_drawlayer_cache_patch_alloc_shared(&g->process.base_patch,
                                            dt_drawlayer_params_cache_hash(imgid, params, layer_width, layer_height),
                                            (size_t)layer_width * layer_height, layer_width, layer_height,
                                            "drawlayer sidecar cache", &created))
  {
    dt_drawlayer_release_all_base_patch_extra_refs(g);
    dt_drawlayer_cache_patch_clear(&g->process.base_patch, "drawlayer patch");
    g->process.cache_valid = FALSE;
    dt_drawlayer_layers_log_errors(errors);
    g_string_free(errors, TRUE);
    return FALSE;
  }
  if(!dt_drawlayer_cache_ensure_mask_buffer(&g->process.stroke_mask, layer_width, layer_height,
                                            "drawlayer stroke mask"))
  {
    dt_drawlayer_release_all_base_patch_extra_refs(g);
    dt_drawlayer_cache_patch_clear(&g->process.base_patch, "drawlayer patch");
    g->process.cache_valid = FALSE;
    dt_drawlayer_layers_append_error(errors, _("failed to allocate drawlayer stroke mask"));
    dt_drawlayer_layers_log_errors(errors);
    g_string_free(errors, TRUE);
    return FALSE;
  }
  if(created)
  {
    dt_drawlayer_cache_patch_wrlock(&g->process.base_patch);
    dt_drawlayer_cache_clear_transparent_float(g->process.base_patch.pixels, (size_t)layer_width * layer_height);
    dt_drawlayer_cache_patch_wrunlock(&g->process.base_patch);
  }
 
  gboolean ok = TRUE;
  gboolean cache_loaded = FALSE;
  gboolean file_exists = FALSE;
  char path[DT_PATH_MAX] = { 0 };
 
  if(!created)
  {
    cache_loaded = TRUE;
  }
  else if(!dt_drawlayer_io_sidecar_path(imgid, path, sizeof(path)))
  {
    dt_drawlayer_release_all_base_patch_extra_refs(g);
    dt_drawlayer_cache_patch_clear(&g->process.base_patch, "drawlayer patch");
    g->process.cache_valid = FALSE;
    dt_drawlayer_layers_append_error(errors, _("failed to resolve drawlayer sidecar path"));
    dt_drawlayer_layers_log_errors(errors);
    g_string_free(errors, TRUE);
    return TRUE;
  }
 
  if(created) file_exists = g_file_test(path, G_FILE_TEST_EXISTS);
 
  if(created && !file_exists)
  {
    cache_loaded = TRUE;
    params->layer_order = -1;
    params->sidecar_timestamp = 0;
  }
  else if(created)
  {
    const gboolean pending_new_layer = (params->layer_order < 0 && params->sidecar_timestamp == 0);
    drawlayer_dir_info_t info = { 0 };
    dt_drawlayer_io_layer_info_t io_info = { 0 };
    if(!dt_drawlayer_io_find_layer(path, params->layer_name, -1, &io_info))
    {
      if(pending_new_layer)
      {
        cache_loaded = TRUE;
      }
      else
      {
        g_snprintf(g->session.missing_layer_error, sizeof(g->session.missing_layer_error),
                   _("The drawing layer \"%s\" was not found in the sidecar TIFF."),
                   params->layer_name);
        params->layer_name[0] = '\0';
        params->layer_order = -1;
        params->sidecar_timestamp = 0;
        memset(params->work_profile, 0, sizeof(params->work_profile));
        dt_drawlayer_release_all_base_patch_extra_refs(g);
        dt_drawlayer_cache_patch_clear(&g->process.base_patch, "drawlayer patch");
        g->process.cache_valid = FALSE;
        g->process.cache_dirty = FALSE;
        dt_drawlayer_paint_runtime_state_reset(&g->process.cache_dirty_rect);
        g->process.cache_imgid = -1;
        g->process.cache_layer_name[0] = '\0';
        g->process.cache_layer_order = -1;
        dt_drawlayer_layers_reset_stroke_session(g);
        dt_drawlayer_process_state_invalidate(&g->process);
      }
    }
    else
    {
      info.found = io_info.found;
      info.index = io_info.index;
      info.count = io_info.count;
      info.width = io_info.width;
      info.height = io_info.height;
      g_strlcpy(info.name, io_info.name, sizeof(info.name));
      g_strlcpy(info.work_profile, io_info.work_profile, sizeof(info.work_profile));
      if(g) g->session.missing_layer_error[0] = '\0';
      params->layer_order = info.index;
      if(info.work_profile[0] != '\0' && params->work_profile[0] == '\0')
        g_strlcpy(params->work_profile, info.work_profile, sizeof(params->work_profile));
 
      if(have_current_profile && info.work_profile[0] != '\0' && g_strcmp0(info.work_profile, current_profile))
        dt_drawlayer_layers_append_error(errors, _("drawlayer sidecar profile mismatch"));
 
      dt_drawlayer_cache_patch_wrlock(&g->process.base_patch);
      dt_drawlayer_io_patch_t io_patch = {
        .x = g->process.base_patch.x,
        .y = g->process.base_patch.y,
        .width = g->process.base_patch.width,
        .height = g->process.base_patch.height,
        .pixels = g->process.base_patch.pixels,
      };
      const gboolean loaded
          = dt_drawlayer_io_load_layer(path, params->layer_name, info.index, layer_width, layer_height, &io_patch);
      dt_drawlayer_cache_patch_wrunlock(&g->process.base_patch);
      if(!loaded)
      {
        dt_drawlayer_layers_append_error(errors, _("failed to read drawing layer sidecar"));
        ok = FALSE;
      }
      else
      {
        params->sidecar_timestamp = dt_drawlayer_sidecar_timestamp_from_path(path);
        cache_loaded = TRUE;
      }
    }
  }
 
  if(cache_loaded)
  {
    g->process.cache_valid = TRUE;
    g->process.cache_dirty = FALSE;
    dt_drawlayer_paint_runtime_state_reset(&g->process.cache_dirty_rect);
    g->process.cache_imgid = imgid;
    g_strlcpy(g->process.cache_layer_name, params->layer_name, sizeof(g->process.cache_layer_name));
    g->process.cache_layer_order = params->layer_order;
    if(ui_thread && g->controls.layer_select) dt_drawlayer_layers_populate_list(self);
    if(created) dt_drawlayer_retain_base_patch_loaded_ref(g);
  }
  else if(dt_drawlayer_layer_name_non_empty(params->layer_name))
  {
    dt_drawlayer_release_all_base_patch_extra_refs(g);
    dt_drawlayer_cache_patch_clear(&g->process.base_patch, "drawlayer patch");
    g->process.cache_valid = FALSE;
    g->process.cache_dirty = FALSE;
    dt_drawlayer_paint_runtime_state_reset(&g->process.cache_dirty_rect);
  }
 
  if(ui_thread && !cache_loaded) dt_drawlayer_refresh_layer_widgets(self);
  dt_drawlayer_layers_log_errors(errors);
  g_string_free(errors, TRUE);
  return ok || !cache_loaded;
}
 
gboolean dt_drawlayer_flush_layer_cache(dt_iop_module_t *self)
{
  dt_iop_drawlayer_gui_data_t *g = (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self);
  const dt_iop_drawlayer_params_t *params = (const dt_iop_drawlayer_params_t *)self->params;
  if(IS_NULL_PTR(g) || IS_NULL_PTR(self->dev) || !g->process.cache_valid || !g->process.cache_dirty || IS_NULL_PTR(g->process.base_patch.pixels)) return TRUE;
  if(!dt_drawlayer_layer_name_non_empty(params ? params->layer_name : NULL)) return TRUE;
  if(!dt_drawlayer_layer_name_non_empty(g->process.cache_layer_name)) return FALSE;
  if(dt_drawlayer_worker_any_active(g->stroke.worker)) dt_drawlayer_worker_wait_idle(self, g->stroke.worker);
 
  char path[DT_PATH_MAX] = { 0 };
  const int32_t flush_imgid = (g->process.cache_imgid > 0) ? g->process.cache_imgid : self->dev->image_storage.id;
  if(flush_imgid <= 0) return TRUE;
  if(!dt_drawlayer_io_sidecar_path(flush_imgid, path, sizeof(path))) return FALSE;
 
  int final_order = g->process.cache_layer_order;
  const char *work_profile = params ? params->work_profile : "";
  dt_drawlayer_cache_patch_rdlock(&g->process.base_patch);
  dt_drawlayer_io_patch_t io_patch = {
    .x = g->process.base_patch.x,
    .y = g->process.base_patch.y,
    .width = g->process.base_patch.width,
    .height = g->process.base_patch.height,
    .pixels = g->process.base_patch.pixels,
  };
  const gboolean ok
      = dt_drawlayer_io_store_layer(path, g->process.cache_layer_name, g->process.cache_layer_order, work_profile, &io_patch,
                                    g->process.base_patch.width, g->process.base_patch.height, FALSE, &final_order);
  dt_drawlayer_cache_patch_rdunlock(&g->process.base_patch);
  if(!ok) return FALSE;
 
  g->process.cache_layer_order = final_order;
  g->process.cache_dirty = FALSE;
  dt_drawlayer_paint_runtime_state_reset(&g->process.cache_dirty_rect);
 
  dt_iop_drawlayer_params_t *mutable_params = (dt_iop_drawlayer_params_t *)self->params;
  if(mutable_params)
  {
    if(!g_strcmp0(mutable_params->layer_name, g->process.cache_layer_name)) mutable_params->layer_order = final_order;
    mutable_params->sidecar_timestamp = dt_drawlayer_sidecar_timestamp_from_path(path);
    dt_drawlayer_rekey_shared_base_patch(&g->process.base_patch, flush_imgid, mutable_params);
  }
  dt_drawlayer_release_all_base_patch_extra_refs(g);
  return TRUE;
}
 
static gboolean _ensure_widget_cache(dt_iop_module_t *self)
{
  dt_iop_drawlayer_gui_data_t *g = (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self);
  if(IS_NULL_PTR(g) || IS_NULL_PTR(self->dev)) return FALSE;
 
  drawlayer_view_patch_info_t view = { 0 };
  if(!dt_drawlayer_compute_view_patch(self, 0.0f, &view)) return FALSE;
 
  float wx0 = 0.0f, wy0 = 0.0f, wx1 = 0.0f, wy1 = 0.0f;
  if(!dt_drawlayer_layer_bounds_to_widget_bounds(self, view.layer_x0, view.layer_y0, view.layer_x1,
                                                 view.layer_y1, &wx0, &wy0, &wx1, &wy1))
    return FALSE;
 
  const dt_drawlayer_damaged_rect_t live_view_rect = {
    .valid = TRUE,
    .nw = { (int)floorf(view.layer_x0), (int)floorf(view.layer_y0) },
    .se = { (int)ceilf(view.layer_x1), (int)ceilf(view.layer_y1) },
  };
  const dt_drawlayer_damaged_rect_t preview_rect = {
    .valid = TRUE,
    .nw = { (int)floorf(wx0), (int)floorf(wy0) },
    .se = { (int)ceilf(wx1), (int)ceilf(wy1) },
  };
 
  const gboolean same_view = (memcmp(&g->session.live_patch, &view.patch, sizeof(view.patch)) == 0
                              && memcmp(&g->session.live_view_rect, &live_view_rect, sizeof(live_view_rect)) == 0
                              && memcmp(&g->session.preview_rect, &preview_rect, sizeof(preview_rect)) == 0);
 
  if(same_view)
  {
    g->session.last_view_x = dt_dev_viewport_center_x(self->dev);
    g->session.last_view_y = dt_dev_viewport_center_y(self->dev);
    g->session.last_view_scale = dt_dev_viewport_scaling(self->dev);
    return TRUE;
  }
 
  g->session.live_patch = view.patch;
  g->session.live_view_rect = live_view_rect;
  g->session.preview_rect = preview_rect;
 
  dt_drawlayer_worker_reset_backend_path(g->stroke.worker);
  g->session.last_view_x = dt_dev_viewport_center_x(self->dev);
  g->session.last_view_y = dt_dev_viewport_center_y(self->dev);
  g->session.last_view_scale = dt_dev_viewport_scaling(self->dev);
  return TRUE;
}
 
void dt_drawlayer_set_pipeline_realtime_mode(dt_iop_module_t *self, const gboolean state)
{
  if(IS_NULL_PTR(self) || IS_NULL_PTR(self->dev) || IS_NULL_PTR(self->dev->pipe)) return;
  const gboolean was_realtime = dt_dev_pixelpipe_get_realtime(self->dev->pipe);
  dt_dev_pixelpipe_set_realtime(self->dev->pipe, state);
  // Leaving realtime mode (commit / abort / focus-loss) drops the transient stroke params so the pipe
  // renders the committed history state again. Entering does nothing here; heartbeats publish per dab.
  if(!state)
    dt_dev_transient_params_clear(self);
  if(was_realtime != state)
    dt_dev_pixelpipe_resync_history_main(self->dev);
  if(IS_NULL_PTR(self->dev->preview_pipe)) return;
 
  dt_atomic_set_int(&self->dev->preview_pipe->pause, state ? 1 : 0);
  if(state)
    dt_atomic_set_int(&self->dev->preview_pipe->shutdown, TRUE);
}
 
gboolean dt_drawlayer_sync_widget_cache(dt_iop_module_t *self)
{
  dt_iop_drawlayer_gui_data_t *g = (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self);
  if(IS_NULL_PTR(g) || IS_NULL_PTR(self->dev)) return FALSE;
 
  dt_drawlayer_worker_pause(self, g->stroke.worker);
  if(!_ensure_widget_cache(self))
  {
    dt_drawlayer_worker_resume(self, g->stroke.worker);
    return FALSE;
  }
 
  g->session.live_padding = dt_drawlayer_current_live_padding(self);
  dt_drawlayer_worker_resume(self, g->stroke.worker);
  return TRUE;
}