disk.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2010 Andrea Purracchio.
    Copyright (C) 2010-2011, 2013 Henrik Andersson.
    Copyright (C) 2010-2013 johannes hanika.
    Copyright (C) 2010 Stuart Henderson.
    Copyright (C) 2011 Antony Dovgal.
    Copyright (C) 2011 Moritz Lipp.
    Copyright (C) 2011 Olivier Tribout.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2011-2018, 2020 Tobias Ellinghaus.
    Copyright (C) 2012 Christian Tellefsen.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2013 Jake Probst.
    Copyright (C) 2013-2015 Jérémy Rosen.
    Copyright (C) 2013-2015, 2018-2021 Pascal Obry.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2014 Pascal de Bruijn.
    Copyright (C) 2015 Pedro Côrte-Real.
    Copyright (C) 2017 parafin.
    Copyright (C) 2018 Dan Torop.
    Copyright (C) 2019, 2023, 2025 Aurélien PIERRE.
    Copyright (C) 2019 Denis Dyakov.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019, 2022 Philippe Weyland.
    Copyright (C) 2020-2021 Chris Elston.
    Copyright (C) 2020-2021 Diederik Ter Rahe.
    Copyright (C) 2020 Marco.
    Copyright (C) 2021 Hanno Schwalm.
    Copyright (C) 2021 Hubert Kowalski.
    Copyright (C) 2021 Marco Carrarini.
    Copyright (C) 2021 Mark-64.
    Copyright (C) 2021 Ralf Brown.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023 Ricky Moon.
    Copyright (C) 2026 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/>.
*/
 
#include "widgets/bauhaus.h"
#include "common/paths.h"   // DT_PATH_MAX
#include "common/global_mutexes.h"
#include "common/image.h"
#include "common/selection.h"
#include "imageio/imageio_core.h"
#include "imageio/imageio_module.h"
#include "common/utility.h"
#include "common/variables.h"
#include "common/conf.h"
#include "control/signal.h"
#include "control/user_message.h"
#include "widgets/button.h"
#include "widgets/paint.h"
#include "gui/application.h"
#include "widgets/gtkentry.h"
#include "imageio/storage/imageio_storage_api.h"
#ifdef GDK_WINDOWING_QUARTZ
#endif
#include <glib.h>
#include <glib/gstdio.h>
#include <stdio.h>
#include <stdlib.h>
#include "common/module_versioning.h"
 
DT_MODULE(3)
 
typedef enum dt_disk_onconflict_actions_t
{
  DT_EXPORT_ONCONFLICT_UNIQUEFILENAME = 0,
  DT_EXPORT_ONCONFLICT_OVERWRITE = 1,
  DT_EXPORT_ONCONFLICT_SKIP = 2
} dt_disk_onconflict_actions_t;
 
// gui data
typedef struct disk_t
{
  GtkEntry *entry;
  GtkWidget *onsave_action;
  GtkWidget *preview;
} disk_t;
 
// saved params
typedef struct dt_imageio_disk_t
{
  char filename[DT_MAX_PATH_FOR_PARAMS];
  dt_disk_onconflict_actions_t onsave_action;
  dt_variables_params_t *vp;
} dt_imageio_disk_t;
 
 
const char *name(const struct dt_imageio_module_storage_t *self)
{
  return _("File on disk");
}
 
void *legacy_params(dt_imageio_module_storage_t *self, const void *const old_params,
                    const size_t old_params_size, const int old_version, const int new_version,
                    size_t *new_size)
{
  if(old_version == 1 && new_version == 3)
  {
    typedef struct dt_imageio_disk_v1_t
    {
      char filename[1024];
      dt_variables_params_t *vp;
      gboolean overwrite;
    } dt_imageio_disk_v1_t;
 
    dt_imageio_disk_t *n = (dt_imageio_disk_t *)malloc(sizeof(dt_imageio_disk_t));
    dt_imageio_disk_v1_t *o = (dt_imageio_disk_v1_t *)old_params;
 
    g_strlcpy(n->filename, o->filename, sizeof(n->filename));
    n->onsave_action = (o->overwrite) ? DT_EXPORT_ONCONFLICT_OVERWRITE: DT_EXPORT_ONCONFLICT_UNIQUEFILENAME;
 
    *new_size = self->params_size(self);
    return n;
  }
  if(old_version == 2 && new_version == 3)
  {
    typedef struct dt_imageio_disk_v2_t
    {
      char filename[DT_MAX_PATH_FOR_PARAMS];
      gboolean overwrite;
      dt_variables_params_t *vp;
    } dt_imageio_disk_v2_t;
 
    dt_imageio_disk_t *n = (dt_imageio_disk_t *)malloc(sizeof(dt_imageio_disk_t));
    dt_imageio_disk_v2_t *o = (dt_imageio_disk_v2_t *)old_params;
 
    g_strlcpy(n->filename, o->filename, sizeof(n->filename));
    n->onsave_action = (o->overwrite) ? DT_EXPORT_ONCONFLICT_OVERWRITE: DT_EXPORT_ONCONFLICT_UNIQUEFILENAME;
 
    *new_size = self->params_size(self);
    return n;
  }
  return NULL;
}
 
// Same separator handling as import.c's own path-building pipeline (see dt_cleanup_separators()
// in common/utility.c, used through _path_cleanup() in control/jobs/import_jobs.c): normalize to
// the current OS's separator instead of literally escaping '\' into '\\', which is what used to
// make the entry display a doubled backslash on Windows. dt_variables_expand() never treats '\'
// as special, so there is nothing here for that escaping to have protected against.
static void button_clicked(GtkWidget *widget, dt_imageio_module_storage_t *self)
{
  disk_t *d = (disk_t *)self->gui_data;
  GtkWidget *win = dt_gui_main_window();
  GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
        _("select directory"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
        _("_select as output destination"), _("_cancel"));
 
  gchar *old = g_strdup(gtk_entry_get_text(d->entry));
  char *c = g_strstr_len(old, -1, "$");
  if(c) *c = '\0';
  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), old);
  dt_free(old);
  if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    gchar *dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
    char *composed = g_build_filename(dir, "$(FILE_NAME)", NULL);
    gchar *cleaned = dt_cleanup_separators(composed);
 
    gtk_entry_set_text(GTK_ENTRY(d->entry), cleaned); // the signal handler will write this to conf
    gtk_editable_set_position(GTK_EDITABLE(d->entry), strlen(cleaned));
    dt_free(dir);
    dt_free(composed);
    dt_free(cleaned);
  }
  g_object_unref(filechooser);
}
 
// Mirrors import.c's _set_test_path(): resolve the current path pattern against the first
// selected image, so the user can see what the export will actually be named before running it.
static void _update_preview(disk_t *d)
{
  const int32_t imgid = dt_selection_get_first_id(dt_selection_get_global());
  const gchar *pattern = gtk_entry_get_text(d->entry);
 
  if(imgid <= UNKNOWN_IMAGE || !pattern[0])
  {
    gtk_label_set_text(GTK_LABEL(d->preview), _("select an image to preview the export path"));
    return;
  }
 
  char input_dir[DT_PATH_MAX] = { 0 };
  gboolean from_cache = FALSE;
  dt_image_full_path(imgid, input_dir, sizeof(input_dir), &from_cache, __FUNCTION__);
 
  dt_variables_params_t *vp;
  dt_variables_params_init(&vp);
  vp->filename = input_dir;
  vp->jobcode = "export";
  vp->imgid = imgid;
  vp->sequence = 1;
 
  gchar *fixed_path = dt_util_fix_path(pattern);
  gchar *expanded = dt_variables_expand(vp, fixed_path, TRUE);
  dt_free(fixed_path);
 
  dt_imageio_module_format_t *mformat = dt_imageio_get_format();
  dt_imageio_module_data_t *fdata = mformat ? mformat->get_params(mformat) : NULL;
  gchar *full = g_strdup_printf("%s.%s", expanded, fdata ? mformat->extension(fdata) : "");
  if(fdata) mformat->free_params(mformat, fdata);
  dt_free(expanded);
 
  gtk_label_set_text(GTK_LABEL(d->preview), full);
  dt_free(full);
 
  dt_variables_params_destroy(vp);
}
 
static void entry_changed_callback(GtkEntry *entry, gpointer user_data)
{
  dt_imageio_module_storage_t *self = (dt_imageio_module_storage_t *)user_data;
  disk_t *d = (disk_t *)self->gui_data;
  dt_conf_set_string("plugins/imageio/storage/disk/file_directory", gtk_entry_get_text(entry));
  _update_preview(d);
}
 
static void _selection_changed_callback(gpointer instance, dt_imageio_module_storage_t *self)
{
  _update_preview((disk_t *)self->gui_data);
}
 
static void onsave_action_toggle_callback(GtkWidget *widget, gpointer user_data)
{
  dt_conf_set_int("plugins/imageio/storage/disk/overwrite", dt_bauhaus_combobox_get(widget));
}
 
void gui_init(dt_imageio_module_storage_t *self)
{
  disk_t *d = (disk_t *)malloc(sizeof(disk_t));
  self->gui_data = (void *)d;
  self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  GtkWidget *widget;
 
  GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, FALSE, 0);
 
  widget = gtk_entry_new();
  dt_accels_disconnect_on_text_input(widget);
  gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
  const char *dir = dt_conf_get_string_const("plugins/imageio/storage/disk/file_directory");
  if(dir)
  {
    gtk_entry_set_text(GTK_ENTRY(widget), dir);
    gtk_editable_set_position(GTK_EDITABLE(widget), strlen(dir));
  }
 
  dt_gtkentry_setup_completion(GTK_ENTRY(widget), dt_gtkentry_get_default_path_compl_list(), "$(");
 
  d->entry = GTK_ENTRY(widget);
  gtk_entry_set_width_chars(GTK_ENTRY(widget), 0);
  gtk_widget_set_tooltip_text(widget,
      _("enter the path where to put exported images\nvariables support bash like string manipulation\n"
        "type '$(' to activate the completion and see the list of variables"));
  g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(entry_changed_callback), self);
 
  widget = dtgtk_button_new(dtgtk_cairo_paint_directory, CPF_NONE, NULL);
  gtk_widget_set_tooltip_text(widget, _("select directory"));
  gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
  g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(button_clicked), self);
 
  d->onsave_action = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->onsave_action, N_("on conflict"));
  gtk_widget_set_tooltip_text(d->onsave_action, _("Expected behaviour if the current naming pattern\n"
                                                  "produces a filename that already exists."));
  dt_bauhaus_combobox_add(d->onsave_action, _("create unique filename"));
  dt_bauhaus_combobox_add(d->onsave_action, _("overwrite"));
  dt_bauhaus_combobox_add(d->onsave_action, _("skip"));
  gtk_box_pack_start(GTK_BOX(self->widget), d->onsave_action, TRUE, TRUE, 0);
  g_signal_connect(G_OBJECT(d->onsave_action), "value-changed", G_CALLBACK(onsave_action_toggle_callback), self);
  dt_bauhaus_combobox_set(d->onsave_action, dt_conf_get_int("plugins/imageio/storage/disk/overwrite"));
 
  d->preview = gtk_label_new("");
  gtk_widget_set_halign(d->preview, GTK_ALIGN_START);
  gtk_label_set_line_wrap(GTK_LABEL(d->preview), TRUE);
  gtk_label_set_max_width_chars(GTK_LABEL(d->preview), 60);
  gtk_box_pack_start(GTK_BOX(self->widget), d->preview, TRUE, TRUE, 0);
  _update_preview(d);
 
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_SELECTION_CHANGED,
                            G_CALLBACK(_selection_changed_callback), self);
}
 
void gui_cleanup(dt_imageio_module_storage_t *self)
{
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_selection_changed_callback), self);
  dt_free(self->gui_data);
}
 
void gui_reset(dt_imageio_module_storage_t *self)
{
  disk_t *d = (disk_t *)self->gui_data;
  // global default can be annoying:
  // gtk_entry_set_text(GTK_ENTRY(d->entry), "$(FILE_FOLDER)/darktable_exported/$(FILE_NAME)");
  gtk_entry_set_text(d->entry, dt_confgen_get("plugins/imageio/storage/disk/file_directory", DT_DEFAULT));
  dt_bauhaus_combobox_set(d->onsave_action, dt_confgen_get_int("plugins/imageio/storage/disk/overwrite", DT_DEFAULT));
  dt_conf_set_string("plugins/imageio/storage/disk/file_directory", gtk_entry_get_text(d->entry));
  dt_conf_set_int("plugins/imageio/storage/disk/overwrite", dt_bauhaus_combobox_get(d->onsave_action));
}
 
/* Guards the choice of an output filename, which spans images: two threads exporting
 * different images can otherwise settle on the same free name and one silently overwrites
 * the other. Module-owned, and initialised through pthread_once so it is recursive like
 * every other lock created with dt_pthread_mutex_init(..., NULL). */
static dt_pthread_mutex_t _filename_lock;
static pthread_once_t _filename_lock_once = PTHREAD_ONCE_INIT;
 
static void _filename_lock_init(void)
{
  dt_pthread_mutex_init(&_filename_lock, NULL);
}
 
int store(dt_imageio_module_storage_t *self, dt_imageio_module_data_t *sdata, const int32_t imgid,
          dt_imageio_module_format_t *format, dt_imageio_module_data_t *fdata, const double scale_factor,
          const int num, const int total,
          const gboolean high_quality, const gboolean export_masks,
          dt_colorspaces_color_profile_type_t icc_type, const gchar *icc_filename, dt_iop_color_intent_t icc_intent,
          dt_export_metadata_t *metadata)
{
  dt_imageio_disk_t *d = (dt_imageio_disk_t *)sdata;
 
  char filename[DT_PATH_MAX] = { 0 };
  char input_dir[DT_PATH_MAX] = { 0 };
  char pattern[DT_MAX_PATH_FOR_PARAMS];
  g_strlcpy(pattern, d->filename, sizeof(pattern));
  gboolean from_cache = FALSE;
  dt_image_full_path(imgid,  input_dir,  sizeof(input_dir),  &from_cache, __FUNCTION__);
 
  /* Private expansion context, per call.
   *
   * This used to write into d->vp -- ONE dt_variables_params_t owned by the storage module
   * and reused by every image in the export. store() runs in parallel, so two threads
   * exporting different images both assigned ->imgid/->sequence there and then expanded,
   * and the lock around the whole block was what kept that from producing a filename built
   * from another image's variables. A per-call context removes the shared state instead of
   * serializing access to it, which is the actual fix: nothing to race, nothing to lock. */
  dt_variables_params_t *vp = NULL;
  dt_variables_params_init(&vp);
  dt_variables_set_max_width_height(vp, fdata->max_width, fdata->max_height);
 
  gboolean fail = FALSE;
  /* Still serialized, but only for what genuinely spans images: choosing a filename nobody
   * else has taken. That is a check-then-create across the whole export, which no per-image
   * lock can cover. The lock is this module's own now, not a process-wide "plugin" mutex
   * shared with the watermark renderer and rawspeed's metadata init.
   *
   * The mechanism is still not airtight -- another process can create the file between the
   * g_file_test() below and the format writer opening it. The airtight version claims the
   * name with O_CREAT|O_EXCL and retries on EEXIST, which needs the format writers to accept
   * a descriptor instead of a path. Recorded in doc/lock-audit.md. */
  pthread_once(&_filename_lock_once, _filename_lock_init);
  dt_pthread_mutex_lock(&_filename_lock);
  {
try_again:
    // avoid braindead export which is bound to overwrite at random:
    if(total > 1 && !g_strrstr(pattern, "$"))
    {
      snprintf(pattern + strlen(pattern), sizeof(pattern) - strlen(pattern), "_$(SEQUENCE)");
    }
 
    gchar *fixed_path = dt_util_fix_path(pattern);
    g_strlcpy(pattern, fixed_path, sizeof(pattern));
    dt_free(fixed_path);
 
    vp->filename = input_dir;
    vp->jobcode = "export";
    vp->imgid = imgid;
    vp->sequence = num;
 
    gchar *result_filename = dt_variables_expand(vp, pattern, TRUE);
    g_strlcpy(filename, result_filename, sizeof(filename));
    dt_free(result_filename);
 
    // if filenamepattern is a directory just add ${FILE_NAME} as default..
    // this can happen if the filename component of the pattern is an empty variable
    char last_char = *(filename + strlen(filename) - 1);
    if(last_char == '/' || last_char == '\\')
    {
      // add to the end of the original pattern without caring about a
      // potentially added "_$(SEQUENCE)"
      if (snprintf(pattern, sizeof(pattern), "%s" G_DIR_SEPARATOR_S "$(FILE_NAME)", d->filename) < sizeof(pattern))
        goto try_again;
    }
 
    char *output_dir = g_path_get_dirname(filename);
 
    if(g_mkdir_with_parents(output_dir, 0755))
    {
      dt_control_alert(_("Export failed"), _("could not create directory!"), output_dir);
      fail = TRUE;
      goto failed;
    }
    if(g_access(output_dir, W_OK | X_OK) != 0)
    {
      dt_control_alert(_("Export failed"), _("could not write to directory!"), output_dir);
      fail = TRUE;
      goto failed;
    }
 
    const char *ext = format->extension(fdata);
    char *c = filename + strlen(filename);
    size_t filename_free_space = sizeof(filename) - (c - filename);
    snprintf(c, filename_free_space, ".%s", ext);
 
  /* prevent overwrite of files */
  failed:
    dt_free(output_dir);
 
    if(!fail && d->onsave_action == DT_EXPORT_ONCONFLICT_UNIQUEFILENAME)
    {
      int seq = 1;
      while(g_file_test(filename, G_FILE_TEST_EXISTS))
      {
        snprintf(c, filename_free_space, "_%.2d.%s", seq, ext);
        seq++;
      }
    }
 
    if(!fail && d->onsave_action == DT_EXPORT_ONCONFLICT_SKIP)
    {
      if(g_file_test(filename, G_FILE_TEST_EXISTS))
      {
        dt_pthread_mutex_unlock(&_filename_lock);
        dt_variables_params_destroy(vp);
        fprintf(stderr, "[export_job] skipping `%s'\n", filename);
        dt_control_log(ngettext("%d/%d skipping `%s'", "%d/%d skipping `%s'", num),
                       num, total, filename);
        return 0;
      }
    }
  } // end of critical block
  dt_pthread_mutex_unlock(&_filename_lock);
  dt_variables_params_destroy(vp);
  if(fail) return 1;
 
  /* export image to file */
  if(dt_imageio_export(imgid, filename, format, fdata, scale_factor, TRUE, TRUE, export_masks, icc_type,
                       icc_filename, icc_intent, self, sdata, num, total, metadata) != 0)
  {
    dt_control_alert(_("Export failed"), _("could not export to file!"), filename);
    return 1;
  }
 
  fprintf(stderr, "[export_job] exported to `%s'\n", filename);
  dt_control_log(ngettext("%d/%d exported to `%s'", "%d/%d exported to `%s'", num),
                 num, total, filename);
  return 0;
}
 
size_t params_size(dt_imageio_module_storage_t *self)
{
  return sizeof(dt_imageio_disk_t) - sizeof(void *);
}
 
void init(dt_imageio_module_storage_t *self)
{
}
 
void *get_params(dt_imageio_module_storage_t *self)
{
  dt_imageio_disk_t *d = (dt_imageio_disk_t *)calloc(1, sizeof(dt_imageio_disk_t));
 
  const char *text = dt_conf_get_string_const("plugins/imageio/storage/disk/file_directory");
  g_strlcpy(d->filename, text, sizeof(d->filename));
 
  d->onsave_action = dt_conf_get_int("plugins/imageio/storage/disk/overwrite");
 
  d->vp = NULL;
  dt_variables_params_init(&d->vp);
 
  return d;
}
 
void free_params(dt_imageio_module_storage_t *self, dt_imageio_module_data_t *params)
{
  if(IS_NULL_PTR(params)) return;
  dt_imageio_disk_t *d = (dt_imageio_disk_t *)params;
  dt_variables_params_destroy(d->vp);
  dt_free(params);
}
 
int set_params(dt_imageio_module_storage_t *self, const void *params, const int size)
{
  dt_imageio_disk_t *d = (dt_imageio_disk_t *)params;
  disk_t *g = (disk_t *)self->gui_data;
 
  if(size != self->params_size(self)) return 1;
 
  gtk_entry_set_text(GTK_ENTRY(g->entry), d->filename);
  gtk_editable_set_position(GTK_EDITABLE(g->entry), strlen(d->filename));
  dt_bauhaus_combobox_set(g->onsave_action, d->onsave_action);
  return 0;
}
 
char *ask_user_confirmation(dt_imageio_module_storage_t *self)
{
  disk_t *g = (disk_t *)self->gui_data;
  if(dt_bauhaus_combobox_get(g->onsave_action) == DT_EXPORT_ONCONFLICT_OVERWRITE && dt_conf_get_bool("plugins/lighttable/export/ask_before_export_overwrite"))
  {
    return g_strdup(_("you are going to export on overwrite mode, this will overwrite any existing images\n\n"
        "do you really want to continue?"));
  }
  else
  {
    return NULL;
  }
}
 
// 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