film_jobs.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2010 Henrik Andersson.
    Copyright (C) 2010, 2012 johannes hanika.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2014 Jérémy Rosen.
    Copyright (C) 2014, 2016 Tobias Ellinghaus.
    Copyright (C) 2015-2016 Roman Lebedev.
    Copyright (C) 2016 parafin.
    Copyright (C) 2017 luzpaz.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2020-2021 Pascal Obry.
    Copyright (C) 2021 Aldric Renaudin.
    Copyright (C) 2021 Bill Ferguson.
    Copyright (C) 2021 Hanno Schwalm.
    Copyright (C) 2021 Philippe Weyland.
    Copyright (C) 2021 Ralf Brown.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023, 2025 Aurélien PIERRE.
    
    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 "control/jobs/film_jobs.h"
#include "control/settings.h"
#include "common/image_extensions.h"
#include "control/control.h"
#include "common/conf.h"
#include "control/jobs/control_jobs.h"
#include "common/collection.h"
#include "common/film.h"
#include <stdlib.h>
#include "common/utility.h"
#include "gui/application.h"
 
typedef struct dt_film_import1_t
{
  dt_film_t *film;
  GList *imagelist;
} dt_film_import1_t;
 
static void _film_import1(dt_job_t *job, dt_film_t *film, GList *images);
 
static int32_t dt_film_import1_run(dt_job_t *job)
{
  dt_film_import1_t *params = dt_control_job_get_params(job);
  _film_import1(job, params->film, NULL); // import the given film, collecting its images
  dt_pthread_mutex_lock(&params->film->images_mutex);
  params->film->ref--;
  dt_pthread_mutex_unlock(&params->film->images_mutex);
  if(params->film->ref <= 0)
  {
    if(dt_film_is_empty(params->film->id))
    {
      dt_film_remove(params->film->id);
    }
  }
 
  // notify the user via the window manager
  dt_ui_notify_user();
 
  return 0;
}
 
static void dt_film_import1_cleanup(void *p)
{
  dt_film_import1_t *params = p;
 
  dt_film_cleanup(params->film);
  dt_free(params->film);
 
  dt_free(params);
}
 
dt_job_t *dt_film_import1_create(dt_film_t *film)
{
  dt_job_t *job = dt_control_job_create(&dt_film_import1_run, "cache load raw images for preview");
  if(IS_NULL_PTR(job)) return NULL;
  dt_film_import1_t *params = (dt_film_import1_t *)calloc(1, sizeof(dt_film_import1_t));
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return NULL;
  }
  dt_control_job_add_progress(job, _("import images"), FALSE);
  dt_control_job_set_params(job, params, dt_film_import1_cleanup);
  params->film = film;
  dt_pthread_mutex_lock(&film->images_mutex);
  film->ref++;
  dt_pthread_mutex_unlock(&film->images_mutex);
  return job;
}
 
static int32_t _pathlist_import_run(dt_job_t *job)
{
  dt_film_import1_t *params = dt_control_job_get_params(job);
  _film_import1(job, NULL, params->imagelist); // import the specified images, creating filmrolls as needed
  params->imagelist = NULL;  // the import will have freed the image list
 
  // notify the user via the window manager
  dt_ui_notify_user();
  return 0;
}
 
static void _pathlist_import_cleanup(void *p)
{
  dt_film_import1_t *params = p;
  dt_free(params);
}
 
dt_job_t *dt_pathlist_import_create(int argc, char *argv[])
{
  dt_job_t *job = dt_control_job_create(&_pathlist_import_run, "import commandline images");
  if(IS_NULL_PTR(job)) return NULL;
  dt_film_import1_t *params = (dt_film_import1_t *)calloc(1, sizeof(dt_film_import1_t));
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return NULL;
  }
  dt_control_job_add_progress(job, _("import images"), FALSE);
  dt_control_job_set_params(job, params, _pathlist_import_cleanup);
  params->film = NULL;
  // now collect all of the images to be imported
  params->imagelist = NULL;
  for(int i = 1; i < argc; i++)
  {
    char *path = dt_util_normalize_path(argv[i]);
    if(!g_file_test(path, G_FILE_TEST_IS_DIR))
    {
      // add just the given name to the list of images to import
      params->imagelist = g_list_prepend(params->imagelist, path);
    }
    else
    {
      // iterate over the directory, extracting image files
      GDir *cdir = g_dir_open(path, 0, NULL);
      if (cdir)
      {
        while(TRUE)
        {
          const gchar *fname = g_dir_read_name(cdir);
          if(IS_NULL_PTR(fname)) break;       // no more files in directory
          if(fname[0] == '.') continue;   // skip hidden files
          gchar *fullname = g_build_filename(path, fname, NULL);
          if(!g_file_test(fullname, G_FILE_TEST_IS_DIR) && dt_supported_image(fname))
            params->imagelist = g_list_prepend(params->imagelist, fullname);
          else
            dt_free(fullname);
        }
      }
      g_dir_close(cdir);
      dt_free(path);
    }
  }
  params->imagelist = g_list_reverse(params->imagelist);
  return job;
}
 
static GList *_film_recursive_get_files(const gchar *path, gboolean recursive, GList **result)
{
  gchar *fullname;
 
  /* let's try open current dir */
  GDir *cdir = g_dir_open(path, 0, NULL);
  if(IS_NULL_PTR(cdir)) return *result;
 
  /* lets read all files in current dir, recurse
     into directories if we should import recursive.
   */
  do
  {
    /* get the current filename */
    const gchar *filename = g_dir_read_name(cdir);
 
    /* return if no more files are in current dir */
    if(IS_NULL_PTR(filename)) break;
    if(filename[0] == '.') continue;
 
    /* build full path for filename */
    fullname = g_build_filename(path, filename, NULL);
 
    /* recurse into directory if we hit one and we doing a recursive import */
    if(recursive && g_file_test(fullname, G_FILE_TEST_IS_DIR))
    {
      *result = _film_recursive_get_files(fullname, recursive, result);
      dt_free(fullname);
    }
    /* or test if we found a supported image format to import */
    else if(!g_file_test(fullname, G_FILE_TEST_IS_DIR) && dt_supported_image(filename))
      *result = g_list_prepend(*result, fullname);
    else
      dt_free(fullname);
 
  } while(TRUE);
 
  /* cleanup and return results */
  g_dir_close(cdir);
 
  return *result;
}
 
/* check if we can find a gpx data file to be auto applied
   to images in the just imported filmroll
*/
static void _apply_filmroll_gpx(dt_film_t *cfr)
{
  if(!IS_NULL_PTR(cfr) && cfr->dir)
  {
    g_dir_rewind(cfr->dir);
    const gchar *dfn = NULL;
    while((dfn = g_dir_read_name(cfr->dir)) != NULL)
    {
      /* check if we have a gpx to be auto applied to filmroll */
      const size_t len = strlen(dfn);
      if(strcmp(dfn + len - 4, ".gpx") == 0 || strcmp(dfn + len - 4, ".GPX") == 0)
      {
        gchar *gpx_file = g_build_path(G_DIR_SEPARATOR_S, cfr->dirname, dfn, NULL);
        gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
        dt_control_gpx_apply(gpx_file, cfr->id, tz, NULL);
        dt_free(gpx_file);
        dt_free(tz);
      }
    }
  }
}
 
/* compare used for sorting the list of files to import
   only sort on basename of full path eg. the actually filename.
*/
static int _film_filename_cmp(gchar *a, gchar *b)
{
  gchar *a_basename = g_path_get_basename(a);
  gchar *b_basename = g_path_get_basename(b);
  const int ret = g_strcmp0(a_basename, b_basename);
  dt_free(a_basename);
  dt_free(b_basename);
  return ret;
}
 
static void _film_import1(dt_job_t *job, dt_film_t *film, GList *images)
{
  // first, gather all images to import if not already given
  if (IS_NULL_PTR(images))
  {
    const gboolean recursive = dt_conf_get_bool("ui_last/import_recursive");
 
    images = _film_recursive_get_files(film->dirname, recursive, &images);
    if(IS_NULL_PTR(images))
    {
      dt_control_log(_("no supported images were found to be imported"));
      return;
    }
  }
 
  if(IS_NULL_PTR(images))
  {
    // no error message, lua probably emptied the list on purpose
    return;
  }
 
  /* we got ourself a list of images, lets sort and start import */
  images = g_list_sort(images, (GCompareFunc)_film_filename_cmp);
 
  /* let's start import of images */
  gchar message[512] = { 0 };
  double fraction = 0;
  const guint total = g_list_length(images);
  g_snprintf(message, sizeof(message) - 1, ngettext("Importing %d image", "Importing %d images", total), total);
  dt_control_job_set_progress_message(job, message);
 
  GList *all_imgs = NULL;
  gint64 last_collection_refresh = 0;
 
  /* loop thru the images and import to current film roll */
  dt_film_t *cfr = film;
  int32_t imgid = UNKNOWN_IMAGE;
  // dt_collection_load_filmroll() below must be pointed at the FIRST successfully imported
  // image, like import_jobs.c's _control_import_job_run() does (its imgid there is the one from
  // index==0). imgid alone can't be reused for that: the loop overwrites it every iteration, so
  // by the end it holds the LAST image instead -- for a flat single-folder import both are the
  // same directory, but for a recursive import spanning several sub-folders they can differ,
  // making it unpredictable which sub-folder ends up displayed.
  int32_t first_imgid = UNKNOWN_IMAGE;
  for(GList *image = images; image; image = g_list_next(image))
  {
    gchar *cdn = g_path_get_dirname((const gchar *)image->data);
 
    /* check if we need to initialize a new filmroll */
    if(IS_NULL_PTR(cfr) || g_strcmp0(cfr->dirname, cdn) != 0)
    {
      _apply_filmroll_gpx(cfr);
 
      /* cleanup previously imported filmroll*/
      if(cfr && cfr != film)
      {
        if(dt_film_is_empty(cfr->id))
        {
          dt_film_remove(cfr->id);
        }
        dt_film_cleanup(cfr);
        dt_free(cfr);
      }
 
      /* initialize and create a new film to import to */
      cfr = malloc(sizeof(dt_film_t));
      dt_film_init(cfr);
      dt_film_new(cfr, cdn);
    }
 
    dt_free(cdn);
 
    /* import image */
    imgid = dt_image_import(cfr->id, (const gchar *)image->data, FALSE);
    if(first_imgid <= UNKNOWN_IMAGE && imgid > UNKNOWN_IMAGE)
    {
      first_imgid = imgid;
      // Point mouse_over_id at the first imported image as soon as we know it, not only once the
      // whole (possibly long, recursive) import finishes -- darkroom's try_enter() reads this to
      // pick its target image. The dt_collection_load_filmroll() call below is told (via its
      // set_mouse_over=FALSE argument) not to redo this at the end, so a mouse-over change from
      // the user during the import is not clobbered once the job completes.
      dt_control_set_mouse_over_id(first_imgid);
    }
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
 
    // cfr->dirname is imgid's folder for free: this import path never copies files, so the film
    // roll it was just inserted into (created/reused a few lines above from the source path's own
    // dirname) already names its final location -- no need to make notify_imported() re-derive it.
    dt_collection_notify_imported(imgid, cfr->dirname, &last_collection_refresh);
 
    all_imgs = g_list_prepend(all_imgs, GINT_TO_POINTER(imgid));
  }
 
  g_list_free_full(images, dt_free_gpointer);
  images = NULL;
  all_imgs = g_list_reverse(all_imgs);
 
  // only redraw at the end, to not spam the cpu with exposure events
  dt_control_queue_redraw_center();
 
  // set_mouse_over = FALSE: already pointed at first_imgid as soon as it was known, above --
  // do not force it back here and clobber whatever the user may be hovering by now.
  dt_collection_load_filmroll(dt_collection_get_global(), first_imgid,
                              (g_list_length(all_imgs) == 1) ? DT_COLLECTION_IMPORT_VIEW_IMAGE
                                                             : DT_COLLECTION_IMPORT_VIEW_GRID,
                              FALSE);
 
  // dt_collection_load_filmroll() silently declines to switch/refresh the collection when it
  // cannot switch folders -- e.g. the collect module is not on the "Folders" tab (see
  // dt_collection_load_filmroll() in common/collection.c). Without this, a recursive
  // folder import (dt_film_import(), reached from CLI/D-Bus/macOS "open with" while Ansel is
  // already running) never shows up in the lighttable grid or the Collect module until the user
  // reloads the collection by hand -- the same reason control/jobs/import_jobs.c's import job
  // does it too, which this legacy, separate import path does not share code with.
  if(all_imgs)
    dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_NEW_QUERY, DT_COLLECTION_PROP_UNDEF, NULL);
 
  //QUESTION: should this come after _apply_filmroll_gpx, since that can change geotags again?
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_GEOTAG_CHANGED, all_imgs, 0);
 
  _apply_filmroll_gpx(cfr);
 
  /* cleanup previously imported filmroll*/
  if(!IS_NULL_PTR(cfr) && cfr != film)
  {
    dt_film_cleanup(cfr);
    dt_free(cfr);
  }
}
 
// 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