imageio_module.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2010-2011 Henrik Andersson.
    Copyright (C) 2010-2012 johannes hanika.
    Copyright (C) 2011-2016, 2020 Tobias Ellinghaus.
    Copyright (C) 2012-2014 Jérémy Rosen.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Ulrich Pegelow.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019 jakubfi.
    Copyright (C) 2019-2021 Pascal Obry.
    Copyright (C) 2020 a.
    Copyright (C) 2020 Andreas Schneider.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020-2021 Diederik Ter Rahe.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2021 Bill Ferguson.
    Copyright (C) 2021 Ralf Brown.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023 Alynx Zhou.
    
    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 "common/imageio_module.h"
#include "common/darktable.h"
#include "common/file_location.h"
#include "common/imageio.h"
#include "control/conf.h"
#include "control/control.h"
#include "control/signal.h"
#include <stdlib.h>
static gint dt_imageio_sort_modules_storage(gconstpointer a, gconstpointer b)
{
  const dt_imageio_module_storage_t *am = (const dt_imageio_module_storage_t *)a;
  const dt_imageio_module_storage_t *bm = (const dt_imageio_module_storage_t *)b;
  return strcmp(am->name(am), bm->name(bm));
}
 
static gint dt_imageio_sort_modules_format(gconstpointer a, gconstpointer b)
{
  const dt_imageio_module_format_t *am = (const dt_imageio_module_format_t *)a;
  const dt_imageio_module_format_t *bm = (const dt_imageio_module_format_t *)b;
  return strcmp(am->name(), bm->name());
}
 
static int _default_format_dimension(dt_imageio_module_format_t *module, dt_imageio_module_data_t *data,
                                     uint32_t *width, uint32_t *height)
{
  // assume no limits
  *width = 0;
  *height = 0;
  return 0;
}
static int _default_format_flags(dt_imageio_module_data_t *data)
{
  return 0;
}
static int _default_format_levels(dt_imageio_module_data_t *data)
{
  return IMAGEIO_RGB | IMAGEIO_INT8;
}
static void _default_format_gui_init(struct dt_imageio_module_format_t *self)
{
}
 
static int dt_imageio_load_module_format(dt_imageio_module_format_t *module, const char *libname,
                                         const char *module_name)
{
  g_strlcpy(module->plugin_name, module_name, sizeof(module->plugin_name));
 
#define INCLUDE_API_FROM_MODULE_LOAD "imageio_load_module_format"
#include "imageio/format/imageio_format_api.h"
 
  if(darktable.gui)
  {
    if(IS_NULL_PTR(module->gui_init)) goto api_h_error;
  }
  else
  {
    module->gui_init = _default_format_gui_init;
  }
  if(IS_NULL_PTR(module->dimension)) module->dimension = _default_format_dimension;
  if(IS_NULL_PTR(module->flags)) module->flags = _default_format_flags;
  if(IS_NULL_PTR(module->levels)) module->levels = _default_format_levels;
 
  module->widget = NULL;
  // Can by set by the module function to false if something went wrong.
  module->ready = TRUE;
 
  module->init(module);
  if (!module->ready)
  {
    goto api_h_error;
  }
 
  return 0;
}
 
 
static int dt_imageio_load_modules_format(dt_imageio_t *iio)
{
  iio->plugins_format = NULL;
  GList *res = NULL;
  dt_imageio_module_format_t *module;
  char moduledir[PATH_MAX] = { 0 }, plugin_name[256];
  const gchar *d_name;
  dt_loc_get_moduledir(moduledir, sizeof(moduledir));
  g_strlcat(moduledir, "/plugins/imageio/format", sizeof(moduledir));
  GDir *dir = g_dir_open(moduledir, 0, NULL);
  if(IS_NULL_PTR(dir)) return 1;
  const int name_offset = strlen(SHARED_MODULE_PREFIX),
            name_end = strlen(SHARED_MODULE_PREFIX) + strlen(SHARED_MODULE_SUFFIX);
  while((d_name = g_dir_read_name(dir)))
  {
    // get lib*.so
    if(!g_str_has_prefix(d_name, SHARED_MODULE_PREFIX)) continue;
    if(!g_str_has_suffix(d_name, SHARED_MODULE_SUFFIX)) continue;
    g_strlcpy(plugin_name, d_name + name_offset, strlen(d_name) - name_end + 1);
    module = (dt_imageio_module_format_t *)malloc(sizeof(dt_imageio_module_format_t));
    gchar *libname = g_module_build_path(moduledir, (const gchar *)plugin_name);
    if(dt_imageio_load_module_format(module, libname, plugin_name))
    {
      dt_free(module);
      continue;
    }
    module->gui_data = NULL;
    if(darktable.gui) ++darktable.gui->reset;
    module->gui_init(module);
    if(darktable.gui) --darktable.gui->reset;
    if(module->widget) g_object_ref_sink(module->widget);
    dt_free(libname);
    res = g_list_insert_sorted(res, module, dt_imageio_sort_modules_format);
  }
  g_dir_close(dir);
  iio->plugins_format = res;
  return 0;
}
 
static gboolean default_supported(struct dt_imageio_module_storage_t *self,
                                  struct dt_imageio_module_format_t *format)
{
  return TRUE;
}
static int _default_storage_dimension(struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data,
                                      uint32_t *width, uint32_t *height)
{
  return 0;
}
static void _default_storage_nop(struct dt_imageio_module_storage_t *self)
{
}
 
static int dt_imageio_load_module_storage(dt_imageio_module_storage_t *module, const char *libname,
                                          const char *module_name)
{
  g_strlcpy(module->plugin_name, module_name, sizeof(module->plugin_name));
 
#define INCLUDE_API_FROM_MODULE_LOAD "imageio_load_module_storage"
#include "imageio/storage/imageio_storage_api.h"
 
  if(darktable.gui)
  {
    if(IS_NULL_PTR(module->gui_init)) goto api_h_error;
  }
  else
  {
    module->gui_init = _default_storage_nop;
  }
  if(IS_NULL_PTR(module->dimension)) module->dimension = _default_storage_dimension;
  if(IS_NULL_PTR(module->recommended_dimension)) module->recommended_dimension = _default_storage_dimension;
  if(!module->export_dispatched) module->export_dispatched = _default_storage_nop;
 
  module->widget = NULL;
  module->init(module);
  return 0;
}
 
static int dt_imageio_load_modules_storage(dt_imageio_t *iio)
{
  iio->plugins_storage = NULL;
  dt_imageio_module_storage_t *module;
  char moduledir[PATH_MAX] = { 0 }, plugin_name[256];
  const gchar *d_name;
  dt_loc_get_moduledir(moduledir, sizeof(moduledir));
  g_strlcat(moduledir, "/plugins/imageio/storage", sizeof(moduledir));
  GDir *dir = g_dir_open(moduledir, 0, NULL);
  if(IS_NULL_PTR(dir)) return 1;
  const int name_offset = strlen(SHARED_MODULE_PREFIX),
            name_end = strlen(SHARED_MODULE_PREFIX) + strlen(SHARED_MODULE_SUFFIX);
  while((d_name = g_dir_read_name(dir)))
  {
    // get lib*.so
    if(!g_str_has_prefix(d_name, SHARED_MODULE_PREFIX)) continue;
    if(!g_str_has_suffix(d_name, SHARED_MODULE_SUFFIX)) continue;
    g_strlcpy(plugin_name, d_name + name_offset, strlen(d_name) - name_end + 1);
    module = (dt_imageio_module_storage_t *)malloc(sizeof(dt_imageio_module_storage_t));
    gchar *libname = g_module_build_path(moduledir, (const gchar *)plugin_name);
    if(dt_imageio_load_module_storage(module, libname, plugin_name))
    {
      dt_free(module);
      continue;
    }
    module->gui_data = NULL;
    module->gui_init(module);
    if(module->widget) g_object_ref_sink(module->widget);
    dt_free(libname);
    dt_imageio_insert_storage(module);
  }
  g_dir_close(dir);
  return 0;
}
 
void dt_imageio_init(dt_imageio_t *iio)
{
  iio->plugins_format = NULL;
  iio->plugins_storage = NULL;
 
  dt_imageio_load_modules_format(iio);
  dt_imageio_load_modules_storage(iio);
}
 
void dt_imageio_cleanup(dt_imageio_t *iio)
{
  while(iio->plugins_format)
  {
    dt_imageio_module_format_t *module = (dt_imageio_module_format_t *)(iio->plugins_format->data);
    module->gui_cleanup(module);
    module->cleanup(module);
    if(module->widget) g_object_unref(module->widget);
    if(module->module) g_module_close(module->module);
    dt_free(module);
    iio->plugins_format = g_list_delete_link(iio->plugins_format, iio->plugins_format);
  }
  while(iio->plugins_storage)
  {
    dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)(iio->plugins_storage->data);
    module->gui_cleanup(module);
    if(module->widget) g_object_unref(module->widget);
    if(module->module) g_module_close(module->module);
    dt_free(module);
    iio->plugins_storage = g_list_delete_link(iio->plugins_storage, iio->plugins_storage);
  }
}
 
dt_imageio_module_format_t *dt_imageio_get_format()
{
  dt_imageio_t *iio = darktable.imageio;
  const char *format_name = dt_conf_get_string_const("plugins/lighttable/export/format_name");
  dt_imageio_module_format_t *format = dt_imageio_get_format_by_name(format_name);
  // if the format from the config isn't available default to jpeg, if that's not available either just use
  // the first we have
  if(IS_NULL_PTR(format)) format = dt_imageio_get_format_by_name("jpeg");
  if(IS_NULL_PTR(format)) format = iio->plugins_format->data;
  return format;
}
 
dt_imageio_module_storage_t *dt_imageio_get_storage()
{
  dt_imageio_t *iio = darktable.imageio;
  const char *storage_name = dt_conf_get_string_const("plugins/lighttable/export/storage_name");
  dt_imageio_module_storage_t *storage = dt_imageio_get_storage_by_name(storage_name);
  // if the storage from the config isn't available default to disk, if that's not available either just use
  // the first we have
  if(IS_NULL_PTR(storage)) storage = dt_imageio_get_storage_by_name("disk");
  if(IS_NULL_PTR(storage)) storage = iio->plugins_storage->data;
  return storage;
}
 
dt_imageio_module_format_t *dt_imageio_get_format_by_name(const char *name)
{
  if(IS_NULL_PTR(name)) return NULL;
  dt_imageio_t *iio = darktable.imageio;
  for(GList *it = iio->plugins_format; it; it = g_list_next(it))
  {
    dt_imageio_module_format_t *module = (dt_imageio_module_format_t *)it->data;
    if(!strcmp(module->plugin_name, name)) return module;
  }
  return NULL;
}
 
dt_imageio_module_storage_t *dt_imageio_get_storage_by_name(const char *name)
{
  if(IS_NULL_PTR(name)) return NULL;
  dt_imageio_t *iio = darktable.imageio;
  for(GList *it = iio->plugins_storage; it; it = g_list_next(it))
  {
    dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)it->data;
    if(!strcmp(module->plugin_name, name)) return module;
  }
  return NULL;
}
 
dt_imageio_module_format_t *dt_imageio_get_format_by_index(int index)
{
  dt_imageio_t *iio = darktable.imageio;
  GList *it = g_list_nth(iio->plugins_format, index);
  if(IS_NULL_PTR(it)) it = iio->plugins_format;
  return (dt_imageio_module_format_t *)it->data;
}
 
dt_imageio_module_storage_t *dt_imageio_get_storage_by_index(int index)
{
  dt_imageio_t *iio = darktable.imageio;
  GList *it = g_list_nth(iio->plugins_storage, index);
  if(IS_NULL_PTR(it)) it = iio->plugins_storage;
  return (dt_imageio_module_storage_t *)it->data;
}
 
int dt_imageio_get_index_of_format(dt_imageio_module_format_t *format)
{
  dt_imageio_t *iio = darktable.imageio;
  return g_list_index(iio->plugins_format, format);
}
int dt_imageio_get_index_of_storage(dt_imageio_module_storage_t *storage)
{
  dt_imageio_t *iio = darktable.imageio;
  return g_list_index(iio->plugins_storage, storage);
}
 
void dt_imageio_insert_storage(dt_imageio_module_storage_t *storage)
{
  darktable.imageio->plugins_storage
      = g_list_insert_sorted(darktable.imageio->plugins_storage, storage, dt_imageio_sort_modules_storage);
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_IMAGEIO_STORAGE_CHANGE);
}
 
void dt_imageio_remove_storage(dt_imageio_module_storage_t *storage)
{
  darktable.imageio->plugins_storage  = g_list_remove(darktable.imageio->plugins_storage, storage);
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_IMAGEIO_STORAGE_CHANGE);
}
 
gchar *dt_imageio_resizing_factor_get_and_parsing(double *num, double *denum)
{
  double _num, _denum;
  gchar *scale_str = dt_conf_get_string("plugins/lighttable/export/resizing_factor");
 
  char sep[4] = "";
  snprintf( sep, 4, "%g", (double) 3/2);
  int i = -1;
  while(scale_str[++i])
  {
      if ((scale_str[i] == '.') || (scale_str[i] == ',')) scale_str[i] = sep[1];
  }
 
  gchar *pdiv = strchr(scale_str, '/');
 
  if (IS_NULL_PTR(pdiv))
  {
    _num = atof(scale_str);
    _denum = 1;
  }
  else if (pdiv-scale_str == 0)
  {
    _num = 1;
    _denum = atof(pdiv + 1);
}
  else
{
    _num = atof(scale_str);
    _denum = atof(pdiv+1);
  }
 
  if (_num == 0.0) _num = 1.0;
  if (_denum == 0.0) _denum = 1.0;
 
  *num = _num;
  *denum = _denum;
 
  dt_conf_set_string("plugins/lighttable/export/resizing_factor", scale_str);
  return scale_str;
}
 
// 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