imageop.h

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2013 johannes hanika.
    Copyright (C) 2010-2012 Henrik Andersson.
    Copyright (C) 2011 Edouard Gomez.
    Copyright (C) 2011-2012 Jérémy Rosen.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2011 Rostyslav Pidgornyi.
    Copyright (C) 2011-2014, 2016, 2018-2019 Tobias Ellinghaus.
    Copyright (C) 2011-2017 Ulrich Pegelow.
    Copyright (C) 2012-2013, 2019-2021 Aldric Renaudin.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2013, 2018-2022 Pascal Obry.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Simon Spannagel.
    Copyright (C) 2014, 2021 Dan Torop.
    Copyright (C) 2014 Mikhail Trishchenkov.
    Copyright (C) 2016 Pedro Côrte-Real.
    Copyright (C) 2017-2019 Edgardo Hoszowski.
    Copyright (C) 2019-2020 Heiko Bauke.
    Copyright (C) 2020, 2022-2026 Aurélien PIERRE.
    Copyright (C) 2020, 2022 Chris Elston.
    Copyright (C) 2020-2022 Diederik Ter Rahe.
    Copyright (C) 2020 Harold le Clément de Saint-Marcq.
    Copyright (C) 2020 Philippe Weyland.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2021-2022 Hanno Schwalm.
    Copyright (C) 2021 Marco.
    Copyright (C) 2021 Mark-64.
    Copyright (C) 2021 Paolo DePetrillo.
    Copyright (C) 2021 Sakari Kapanen.
    Copyright (C) 2022 luzpaz.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Philipp Lutz.
    Copyright (C) 2023 Luca Zulberti.
    Copyright (C) 2024-2025 Alynx Zhou.
    Copyright (C) 2025 Guillaume Stutin.
    
    darktable is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    darktable is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef DT_DEVELOP_IMAGEOP_H
#define DT_DEVELOP_IMAGEOP_H
 
#include <gmodule.h>
#include <gtk/gtk.h>
#include <sched.h>
#include <stddef.h>
#include <stdint.h>
 
#include "system/dtpthread.h"
#include "common/logging.h"
#include "system/mem_alloc.h"
#include "system/simd.h"
 
#include "common/introspection.h"
#include "common/gui_module_api.h"
#include "common/opencl.h"
 
#include "history/history.h"   // dt_dev_operation_t, both structs' `op` member
#include "pixel/format.h"
#include "develop/pixelpipe_hb.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct dt_develop_t;
struct dt_dev_pixelpipe_t;
struct dt_dev_pixelpipe_iop_t;
struct dt_develop_blend_params_t;
struct dt_develop_tiling_t;
struct dt_iop_color_picker_t;
/* develop/geometry/geometry.h -- named by the geometry_record() vtable entry. Declared HERE,
 * not only in iop_api.h: that header's forward declarations live inside its FULL_API_H block,
 * which the struct-body expansion of the X-macro does not compile, so the first mention would
 * otherwise be inside a function prototype -- C scopes that to the prototype and the resulting
 * type is distinct from every other declaration of the same name. */
struct dt_geometry_record_t;
 
typedef enum dt_iop_module_header_icons_t
{
  IOP_MODULE_SWITCH = 0,
  IOP_MODULE_ICON,
  IOP_MODULE_LABEL,
  IOP_MODULE_MASK,
  IOP_MODULE_INSTANCE,
  IOP_MODULE_RESET,
  IOP_MODULE_PRESETS,
  IOP_MODULE_LAST
} dt_iop_module_header_icons_t;
 
float dt_dev_get_module_scale(const struct dt_dev_pixelpipe_t *pipe, const dt_iop_roi_t *roi_in);
 
uint32_t dt_dev_get_roi_filters(const struct dt_dev_pixelpipe_iop_t *piece, const dt_iop_roi_t *roi_in);
 
typedef enum dt_iop_group_t
{
  IOP_GROUP_NONE = 0,
  IOP_GROUP_TONES = 1,
  IOP_GROUP_FILM = 2,
  IOP_GROUP_COLOR = 3,
  IOP_GROUP_REPAIR = 4,
  IOP_GROUP_SHARPNESS = 5,
  IOP_GROUP_EFFECTS = 6,
  IOP_GROUP_TECHNICAL= 7,
  IOP_GROUP_LAST
} dt_iop_group_t;
 
typedef enum dt_iop_tags_t
{
  IOP_TAG_NONE = 0,
  IOP_TAG_DISTORT = 1 << 0,
  IOP_TAG_DECORATION = 1 << 1,
  IOP_TAG_CLIPPING = 1 << 2,
 
  // might be some other filters togglable by user?
  // IOP_TAG_SLOW       = 1<<3,
  // IOP_TAG_DETAIL_FIX = 1<<3,
} dt_iop_tags_t;
 
typedef enum dt_iop_flags_t
{
  IOP_FLAGS_NONE = 0,
 
  IOP_FLAGS_INCLUDE_IN_STYLES = 1 << 0,
  IOP_FLAGS_SUPPORTS_BLENDING = 1 << 1, // Does provide blending modes
  IOP_FLAGS_DEPRECATED = 1 << 2,
  IOP_FLAGS_ALLOW_TILING = 1 << 3, // Does allow tile-wise processing (valid for CPU and GPU processing)
  IOP_FLAGS_HIDDEN = 1 << 4,       // Hide the iop from userinterface
  IOP_FLAGS_TILING_FULL_ROI = 1 << 5, // Tiling code has to expect arbitrary roi's for this module (incl. flipping, mirroring etc.)
  IOP_FLAGS_ONE_INSTANCE = 1 << 6,       // The module doesn't support multiple instances
  IOP_FLAGS_PREVIEW_NON_OPENCL = 1 << 7, // Preview pixelpipe of this module must not run on GPU but always on CPU
  IOP_FLAGS_NO_HISTORY_STACK = 1 << 8,   // This iop will never show up in the history stack
  IOP_FLAGS_NO_MASKS = 1 << 9,           // The module doesn't support masks (used with SUPPORT_BLENDING)
  IOP_FLAGS_TAKE_NO_INPUT = 1 << 10,     // The module doesn't use input
  IOP_FLAGS_UNSAFE_COPY = 1 << 11,       // Unsafe to copy as part of history
  IOP_FLAGS_GUIDES_SPECIAL_DRAW = 1 << 12, // handle the grid drawing directly
  IOP_FLAGS_INTERNAL_MASKS = 1 << 13,     // Module uses masks internally, outside of blendops. This advertises the need to commit them to history unconditionnaly.
  IOP_FLAGS_CPU_WRITES_OPENCL = 1 << 14  // Special case where the process() CPU path inits OpenCL vRAM output cache too
} dt_iop_flags_t;
 
typedef struct dt_iop_gui_data_t
{
  // "base type" for all dt_iop_XXXX_gui_data_t types used by iops
  // to avoid compiler error about different sizes of empty structs between C and C++, we need at least one member
  int dummy;
} dt_iop_gui_data_t;
 
typedef void dt_iop_data_t;
typedef void dt_iop_global_data_t;
 
typedef enum dt_dev_request_colorpick_flags_t
{
  DT_REQUEST_COLORPICK_OFF = 0,   // off
  DT_REQUEST_COLORPICK_MODULE = 1 // requested by module (should take precedence)
} dt_dev_request_colorpick_flags_t;
 
/* dt_iop_colorspace_type_t moved to pixel/format.h: it tags a pixel buffer's colour
 * space, which is a layer-2 concept, and colorprofiles/iop_profile.h needs it. */
 
 
typedef struct dt_iop_module_so_t
{
  // Needs to stay on top for casting
  dt_gui_module_t common_fields;
 
#define INCLUDE_API_FROM_MODULE_H
#include "iop/iop_api.h"
 
  dt_dev_operation_t op;
  dt_iop_global_data_t *data;
//  dt_iop_gui_data_t *gui_data;
  int (*process_plain)(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe,
                       const struct dt_dev_pixelpipe_iop_t *piece, const void *const i, void *const o);
 
  // introspection related data
  gboolean have_introspection;
} dt_iop_module_so_t;
 
typedef struct dt_iop_module_t
{
  // Needs to stay on top for casting
  dt_gui_module_t common_fields;
 
#define INCLUDE_API_FROM_MODULE_H
#include "iop/iop_api.h"
 
  dt_dev_operation_t op;
  int32_t instance;
  int iop_order;
  int32_t hide_enable_button;
  dt_dev_request_colorpick_flags_t request_color_pick;
  dt_dev_request_flags_t request_histogram;
  int request_mask_display;
  gboolean bypass_cache;
  int bypass_cache_variant;
  dt_aligned_pixel_t picked_color, picked_color_min, picked_color_max;
  dt_aligned_pixel_t picked_output_color, picked_output_color_min, picked_output_color_max;
  uint32_t *histogram;
  dt_dev_histogram_stats_t histogram_stats;
  uint32_t histogram_max[4];
  dt_iop_colorspace_type_t histogram_cst;
  int histogram_middle_grey;
  // FIXME: this should disappear from there.
  // To access the develop object from backend (pipeline threads), we already have pipe->dev 
  // referenced in the pipeline object.
  // To access the develop object from frontend (GUI), we have the global darktable.develop reference.
  // Splitting like this between frontend/backend makes things clear and legible.
  // This internal reference can be either, and used for writes and reads alike, 
  // which is impossible to track across the program.
  struct dt_develop_t *dev;
  gboolean enabled;
  gboolean default_enabled;
 
  gboolean workflow_enabled;
  dt_iop_params_t *params, *default_params;
  int32_t params_size;
  dt_iop_global_data_t *global_data;
 
  struct dt_iop_module_gui_t *gui;
 
  struct dt_develop_blend_params_t *blend_params, *default_blendop_params;
  struct {
    struct {
      GHashTable *users;
      GHashTable *masks;
    } source;
    struct {
      struct dt_iop_module_t *source;
      int id;
    } sink;
  } raster_mask;
 
 
  dt_iop_module_so_t *so;
 
  int multi_priority; // user may change this
 
  char multi_name[128]; // user may change this name
 
 
  int (*process_plain)(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe,
                       const struct dt_dev_pixelpipe_iop_t *piece, const void *const i, void *const o);
 
  // introspection related data
  gboolean have_introspection;
 
  // parameters hash
  uint64_t hash;
 
  // blendop hash
  // Ideally, this would be added to struct dt_develop_blend_params_t *blendop
  // but since blendops are dumped to DB as a memory blob, we can't change their length
  // without updating version (aka breaking backwards compatibility), and this minor
  // stuff is not worth it.
  uint64_t blendop_hash;
 
} dt_iop_module_t;
 
typedef struct dt_iop_module_static_entry_t
{
  const char *op;                                 
  void (*fill_so)(dt_iop_module_so_t *module);    
} dt_iop_module_static_entry_t;
 
extern const dt_iop_module_static_entry_t dt_iop_static_modules[];
extern const int dt_iop_static_modules_count;
 
void dt_iop_load_modules_so(void);
void dt_iop_unload_modules_so(void);
int dt_iop_load_module_by_so(dt_iop_module_t *module, dt_iop_module_so_t *so, struct dt_develop_t *dev);
int dt_iop_load_module(dt_iop_module_t *module, dt_iop_module_so_t *module_so, struct dt_develop_t *dev);
void dt_iop_cleanup_module(dt_iop_module_t *module);
void dt_iop_init_pipe(struct dt_iop_module_t *module, struct dt_dev_pixelpipe_t *pipe,
                      struct dt_dev_pixelpipe_iop_t *piece);
void dt_iop_cleanup_pipe(struct dt_iop_module_t *module, struct dt_dev_pixelpipe_t *pipe,
                      struct dt_dev_pixelpipe_iop_t *piece);
gboolean dt_iop_so_is_hidden(dt_iop_module_so_t *module);
gboolean dt_iop_is_hidden(dt_iop_module_t *module);
 
gboolean dt_iop_module_instance_exists(dt_iop_module_t *iop);
 
gboolean dt_iop_module_is_in_pipeline(dt_iop_module_t *iop);
 
gboolean dt_iop_module_supports_drawn_mask(dt_iop_module_t *iop);
 
gboolean dt_iop_is_visible(dt_iop_module_t *module);
 
void dt_iop_gui_enter_critical_section(dt_iop_module_t *const module);
 
void dt_iop_gui_leave_critical_section(dt_iop_module_t *const module);
 
GtkWidget *dt_iop_gui_get_off(dt_iop_module_t *module);
gboolean dt_iop_gui_owns_widget(const dt_iop_module_t *module, const GtkWidget *target);
 
void dt_iop_gui_cleanup_module(dt_iop_module_t *module);
void dt_iop_gui_set_enable_button(dt_iop_module_t *module);
void dt_iop_gui_update(dt_iop_module_t *module);
void dt_iop_gui_reset(dt_iop_module_t *module);
void dt_iop_gui_set_expanded(dt_iop_module_t *module, gboolean expanded, gboolean collapse_others);
void dt_iop_gui_update_expanded(dt_iop_module_t *module);
/* duplicate module and return new instance */
dt_iop_module_t *dt_iop_gui_duplicate(dt_iop_module_t *base, gboolean copy_params);
 
void dt_iop_gui_update_header(dt_iop_module_t *module);
 
#define dt_iop_fmt_log(module, fmt, ...) \
  dt_print(DT_DEBUG_PIPE, "[iop-fmt] %-14s " fmt "\n", (module)->op, ##__VA_ARGS__)
 
void dt_iop_commit_params(dt_iop_module_t *module, dt_iop_params_t *params,
                          struct dt_develop_blend_params_t *blendop_params, struct dt_dev_pixelpipe_t *pipe,
                          struct dt_dev_pixelpipe_iop_t *piece);
void dt_iop_commit_blend_params(dt_iop_module_t *module, const struct dt_develop_blend_params_t *blendop_params);
void dt_iop_set_mask_mode(dt_iop_module_t *module, int mask_mode);
void dt_iop_gui_set_expander(dt_iop_module_t *module);
GtkWidget *dt_iop_gui_get_widget(dt_iop_module_t *module);
GtkWidget *dt_iop_gui_get_pluginui(dt_iop_module_t *module);
 
void dt_iop_request_focus(dt_iop_module_t *module);
void dt_iop_default_init(dt_iop_module_t *module);
void dt_iop_load_default_params(dt_iop_module_t *module);
void dt_iop_gui_init(dt_iop_module_t *module);
void dt_iop_reload_defaults(dt_iop_module_t *module);
 
void dt_iop_nap(int32_t usec);
 
dt_iop_module_t *dt_iop_get_colorout_module(void);
/* returns the iop-module found in list with the given name */
dt_iop_module_t *dt_iop_get_module_from_list(GList *iop_list, const char *op);
dt_iop_module_t *dt_iop_get_module(const char *op);
dt_iop_module_t *dt_iop_get_module_by_op_priority(GList *modules, const char *operation, const int multi_priority);
dt_iop_module_t *dt_iop_get_module_by_instance_name(GList *modules, const char *operation, const char *multi_name);
 
gboolean dt_iop_is_first_instance(GList *modules, dt_iop_module_t *module);
 
 
int dt_iop_get_module_flags(const char *op);
 
const gchar *dt_iop_get_localized_name(const gchar *op);
const gchar *dt_iop_get_localized_aliases(const gchar *op);
 
void dt_iop_update_multi_priority(dt_iop_module_t *module, int new_priority);
 
gboolean dt_iop_module_has_raster_mask(const dt_iop_module_t *module);
gboolean dt_iop_module_needs_mask_history(const dt_iop_module_t *module);
gboolean dt_iop_module_needs_mask_history_ext(const dt_iop_module_t *module, gboolean *raster, gboolean *drawn, gboolean *parametric);
 
gboolean dt_iop_is_raster_mask_used(dt_iop_module_t *module, int id);
 
dt_iop_module_t *dt_iop_gui_get_previous_visible_module(dt_iop_module_t *module);
dt_iop_module_t *dt_iop_gui_get_next_visible_module(dt_iop_module_t *module);
gboolean dt_iop_gui_module_is_visible(dt_iop_module_t *module);
gboolean dt_iop_gui_move_module_before(dt_iop_module_t *module, dt_iop_module_t *module_next,
                                       const char *reason);
gboolean dt_iop_gui_commit_iop_order_change(struct dt_develop_t *dev, dt_iop_module_t *module,
                                            gboolean enable, gboolean write_history, const char *reason);
gboolean dt_iop_gui_move_module_after(dt_iop_module_t *module, dt_iop_module_t *module_prev,
                                      const char *reason);
 
// initializes memory.darktable_iop_names
void dt_iop_set_darktable_iop_table();
 
void dt_iop_add_remove_mask_indicator(dt_iop_module_t *module);
 
// format modules description going in tooltips
const char **dt_iop_set_description(dt_iop_module_t *module, const char *main_text,
                                    const char *purpose, const char *input,
                                    const char *process, const char *output);
 
/* _iop_gui_alloc and IOP_GUI_ALLOC/IOP_GUI_FREE live in imageop_gui.h, with the
 * dt_iop_module_gui_t they operate on. */
 
/* bring up module rename dialog */
void dt_iop_gui_rename_module(dt_iop_module_t *module);
 
/* dispatch post-value-changed GUI events within module and commit changes to history */
void dt_iop_gui_changed(dt_iop_module_t *module, GtkWidget *widget, gpointer data);
 
// update all bauhaus widgets in an iop module from their params fields
void dt_bauhaus_update_module(dt_iop_module_t *self);
 
// default callback to connect to value-changed signal for bauhaus widgets
// it will automatically call dt_iop_changed for the right module.
void dt_bauhaus_value_changed_default_callback(GtkWidget *widget);
 
 
void dt_iop_compute_module_hash(dt_iop_module_t *module, GList *masks);
 
// Use module fingerprints to determine if two instances are actually the same
gboolean dt_iop_check_modules_equal(dt_iop_module_t *mod_1, dt_iop_module_t *mod_2);
 
 
gboolean dt_iop_get_cache_bypass(dt_iop_module_t *module);
void dt_iop_set_cache_bypass(dt_iop_module_t *module, gboolean state);
 
void dt_iop_set_cache_bypass_variant(dt_iop_module_t *module, int variant);
 
GList *dt_iop_get_modules_so(void);
 
 
/* Defaults an IOP's input_format()/output_format()/blend_colorspace() callbacks can delegate
 * to. Defined in develop/format.c. They were declared in pixel/format.h, which is layer 2 and
 * had to forward-declare dt_iop_module_t and dt_dev_pixelpipe_t just to say this -- so they
 * moved here, to the module API every caller already includes. */
void default_input_format(struct dt_iop_module_t *self, struct dt_dev_pixelpipe_t *pipe,
                          struct dt_dev_pixelpipe_iop_t *piece, struct dt_iop_buffer_dsc_t *dsc);
 
void default_output_format(struct dt_iop_module_t *self, struct dt_dev_pixelpipe_t *pipe,
                           struct dt_dev_pixelpipe_iop_t *piece, struct dt_iop_buffer_dsc_t *dsc);
 
int default_blend_colorspace(struct dt_iop_module_t *self, struct dt_dev_pixelpipe_t *pipe,
                             const struct dt_dev_pixelpipe_iop_t *piece);
 
#ifdef __cplusplus
}
#endif
 
 
#endif // DT_DEVELOP_IMAGEOP_H
 
// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on