dev_pixelpipe.h

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/>.
*/
#pragma once
 
#include <inttypes.h>
#include <stdint.h>
#include <glib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
void dt_dev_pixelpipe_rebuild_all_real(struct dt_develop_t *dev);
// Force a full rebuild of the pipe, needed when module order is changed.
// Resync the full history, which may be expensive.
// Pixelpipe cache will need to be flushed too when this is called,
// for raster masks to work properly.
#define dt_dev_pixelpipe_rebuild_all(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_rebuild_all_real, (dev))
 
void dt_dev_pixelpipe_update_history_main_real(struct dt_develop_t *dev);
// Invalidate the main image preview in darkroom, resync only the last history item(s)
// with pipeline nodes.
// This is the most common usecase when interacting with modules and masks.
#define dt_dev_pixelpipe_update_history_main(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_update_history_main_real, (dev))
 
void dt_dev_pixelpipe_update_history_preview_real(struct dt_develop_t *dev);
// Invalidate the thumbnail preview in darkroom, resync only the last history item.
#define dt_dev_pixelpipe_update_history_preview(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_update_history_preview_real, (dev))
 
void dt_dev_pixelpipe_update_history_all_real(struct dt_develop_t *dev);
// Invalidate the main image and the thumbnail in darkroom, resync only the last history item.
#define dt_dev_pixelpipe_update_history_all(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_update_history_all_real, (dev))
 
void dt_dev_pixelpipe_update_zoom_main_real(struct dt_develop_t *dev);
// Invalidate the main image preview in darkroom.
// This doesn't resync history at all, only update the coordinates of the region of interest (ROI).
#define dt_dev_pixelpipe_update_zoom_main(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_update_zoom_main_real, (dev))
 
void dt_dev_pixelpipe_update_zoom_preview_real(struct dt_develop_t *dev);
// Invalidate the preview in darkroom.
// This doesn't resync history at all, only update the coordinates of the region of interest (ROI).
#define dt_dev_pixelpipe_update_zoom_preview(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_update_zoom_preview_real, (dev))
 
void dt_dev_pixelpipe_resync_history_all_real(struct dt_develop_t *dev);
// Invalidate the main image and the thumbnail in darkroom.
// Resync the whole history with the pipeline nodes, which may be expensive.
#define dt_dev_pixelpipe_resync_history_all(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_resync_history_all_real, (dev))
 
void dt_dev_pixelpipe_resync_history_main_real(struct dt_develop_t *dev);
// Invalidate the main image in darkroom.
// Resync the whole history with the pipeline nodes, which may be expensive.
#define dt_dev_pixelpipe_resync_history_main(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_resync_history_main_real, (dev))
 
void dt_dev_pixelpipe_resync_history_preview_real(struct dt_develop_t *dev);
// Invalidate the thumbnail in darkroom.
// Resync the whole history with the pipeline nodes, which may be expensive.
#define dt_dev_pixelpipe_resync_history_preview(dev) DT_DEBUG_TRACE_WRAPPER(DT_DEBUG_DEV, dt_dev_pixelpipe_resync_history_preview_real, (dev))
 
// Flush caches of dev pipes and force a full recompute
void dt_dev_pixelpipe_reset_all(struct dt_develop_t *dev);
 
// Queue a pipeline ROI change and reprocess the main image pipeline.
void dt_dev_pixelpipe_change_zoom_main(struct dt_develop_t *dev);
 
// returns the dimensions of a virtual image of size (width_in, height_in) image after processing
// all modules of the pipe. This chains calls to module's modify_roi_out() methods in pipeline order.
// Doesn't actually compute pixels.
// NOTE: pipe must be a real or virtual pipe with nodes; NULL pipes are not supported anymore.
void dt_dev_pixelpipe_get_roi_out(struct dt_dev_pixelpipe_t *pipe, const int width_in,
                                  const int height_in, int *width, int *height);
                                
// Compute and save into each piece->roi_out/in the proper module-wise ROI to achieve
// the desired sizes from roi_out, from end to start. This chains calls to module's modify_roi_in() methods
// in pipeline reverse order.
// Doesn't actually compute pixels.
// NOTE: pipe must be a real or virtual pipe with nodes; NULL pipes are not supported anymore.
void dt_dev_pixelpipe_get_roi_in(struct dt_dev_pixelpipe_t *pipe, const struct dt_iop_roi_t roi_out);
 
// Check if current_module is performing operations that dev->gui_module (active GUI module)
// wants disabled. Use that to disable some features of current_module.
// This is used mostly with distortion operations when the active GUI module
// needs a full-ROI/undistorted input for its own editing mode,
// like moving the framing on the full image.
// WARNING: this doesn't check WHAT particular operations are performed and
// and what operations should be cancelled (nor if they should all be cancelled).
// So far, all the code uses that to prevent distortions on module output, masks and roi_out changes (cropping).
// Meaning ANY of these operations will disable ALL of these operations.
gboolean dt_dev_pixelpipe_activemodule_disables_currentmodule(struct dt_develop_t *dev,
                                                              struct dt_iop_module_t *current_module);
 
// wrapper for cleanup_nodes, create_nodes, synch_all and synch_top, decides upon changed event which one to
// take on. also locks dev->history_mutex.
void dt_dev_pixelpipe_change(struct dt_dev_pixelpipe_t *pipe);
void dt_dev_pixelpipe_sync_virtual(struct dt_develop_t *dev, dt_dev_pixelpipe_change_t flag);
 
// Get the global hash of a pipe node (piece), or a fallback if none.
uint64_t dt_dev_pixelpipe_node_hash(struct dt_dev_pixelpipe_t *pipe, 
                                    const struct dt_dev_pixelpipe_iop_t *piece, 
                                    const struct dt_iop_roi_t, const int pos);
 
const struct dt_dev_pixelpipe_iop_t *dt_dev_pixelpipe_get_module_piece(const struct dt_dev_pixelpipe_t *pipe,
                                                                       const struct dt_iop_module_t *module);
 
const struct dt_dev_pixelpipe_iop_t *dt_dev_pixelpipe_get_prev_enabled_piece(const struct dt_dev_pixelpipe_t *pipe,
                                                                             const struct dt_dev_pixelpipe_iop_t *piece);
 
typedef void (*dt_dev_pixelpipe_cache_ready_callback_t)(gpointer user_data);
 
typedef struct dt_dev_pixelpipe_cache_wait_t
{
  struct dt_dev_pixelpipe_t *pipe;
  const struct dt_iop_module_t *module;
  uint64_t hash;
  dt_dev_pixelpipe_cache_ready_callback_t restart;
  gpointer user_data;
  const char *owner_tag;
  gpointer owner_object;
  uint64_t request_id;
  gboolean connected;
} dt_dev_pixelpipe_cache_wait_t;
 
void dt_dev_pixelpipe_cache_wait_cleanup(dt_dev_pixelpipe_cache_wait_t *wait, const char *reason);
 
void dt_dev_pixelpipe_cache_wait_dump_pending(const char *reason);
 
void dt_dev_pixelpipe_cache_wait_set_owner(dt_dev_pixelpipe_cache_wait_t *wait,
                                           const char *owner_tag,
                                           gpointer owner_object);
 
gboolean dt_dev_pixelpipe_cache_peek_gui(dt_dev_pixelpipe_t *pipe,
                                         const struct dt_dev_pixelpipe_iop_t *piece,
                                         void **data,
                                         struct dt_pixel_cache_entry_t **cache_entry,
                                         dt_dev_pixelpipe_cache_wait_t *wait,
                                         dt_dev_pixelpipe_cache_ready_callback_t restart,
                                         gpointer restart_data);
 
// Direction-independent forward pass that (re)establishes the per-node buffer-format contract
// (dsc_in/dsc_out) for the whole chain from the input image descriptor, and is the single place
// that disables a node whose input is incompatible with what the previous stage publishes.
// MUST run after history/params have been committed (synch_all / synch_top / realtime) and
// BEFORE dt_pixelpipe_get_global_hash(), because that hash is cumulative over enabled nodes.
// dt_dev_pixelpipe_change() calls it automatically; callers that drive a pipe directly
// (export, snapshots) must call it themselves after dt_dev_pixelpipe_synch_all().
void dt_dev_pixelpipe_propagate_formats(struct dt_dev_pixelpipe_t *pipe);
 
// Compute the sequential hash over the pipeline for each module.
// Need to run after dt_dev_pixelpipe_get_roi_in() has updated processed ROI in/out
void dt_pixelpipe_get_global_hash(struct dt_dev_pixelpipe_t *pipe);
 
// Return TRUE if the current backbuffer for the current pipe is in sync with current dev history stack.
gboolean dt_dev_pixelpipe_is_backbufer_valid(struct dt_dev_pixelpipe_t *pipe);
 
// Return TRUE if the current pipeline (topology and node parameters) is in sync with current dev history stack.
gboolean dt_dev_pixelpipe_is_pipeline_valid(struct dt_dev_pixelpipe_t *pipe);
 
 
#ifdef __cplusplus
}
#endif