/* This file is part of GEGL
*
* GEGL is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* GEGL 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with GEGL; if not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2003-2007 Calvin Williamson, Øyvind Kolås
*/
#include "config.h"
#define __GEGL_INIT_C
#include <babl/babl.h>
#include <glib-object.h>
#include <glib/gstdio.h>
#include <glib/gi18n-lib.h>
#include <locale.h>
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef G_OS_WIN32
#include <process.h>
#endif
#ifdef G_OS_WIN32
#include <windows.h>
static HMODULE hLibGeglModule = NULL;
/* DllMain prototype */
BOOL WINAPI DllMain (HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved);
BOOL WINAPI
DllMain (HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved)
{
hLibGeglModule = hinstDLL;
return TRUE;
}
static inline gboolean
pid_is_running (gint pid)
{
HANDLE h;
h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
return (TerminateProcess(h, 0));
}
#else
#include <sys/types.h>
#include <signal.h>
static inline gboolean
pid_is_running (gint pid)
{
return (kill (pid, 0) == 0);
}
#endif
#include <gegl-debug.h>
guint gegl_debug_flags = 0;
#include "gegl-instrument.h"
#include "gegl-init.h"
#include "module/geglmodule.h"
#include "module/geglmoduledb.h"
#include "gegl-types-internal.h"
#include "buffer/gegl-buffer.h"
#include "operation/gegl-operation.h"
#include "operation/gegl-operations.h"
#include "operation/gegl-extension-handler.h"
#include "buffer/gegl-buffer-private.h"
#include "gegl-config.h"
#include "graph/gegl-node.h"
/* if this function is made to return NULL swapping is disabled */
const gchar *
gegl_swap_dir (void)
{
static gchar *swapdir = "";
if (swapdir && swapdir[0] == '\0')
{
if (g_getenv ("GEGL_SWAP"))
{
if (g_str_equal (g_getenv ("GEGL_SWAP"), "RAM"))
swapdir = NULL;
else
swapdir = g_strdup (g_getenv ("GEGL_SWAP"));
}
else
{
swapdir = g_build_filename (g_get_user_cache_dir(),
GEGL_LIBRARY,
"swap",
NULL);
}
/* Fall back to "swapping to RAM" if not able to create swap dir
*/
if (swapdir &&
! g_file_test (swapdir, G_FILE_TEST_IS_DIR) &&
g_mkdir_with_parents (swapdir, S_IRUSR | S_IWUSR | S_IXUSR) != 0)
{
#if 0
gchar *name = g_filename_display_name (swapdir);
g_warning ("unable to create swapdir '%s': %s",
name, g_strerror (errno));
g_free (name);
#endif
swapdir = NULL;
}
}
return swapdir;
};
static gboolean gegl_post_parse_hook (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error);
static GeglConfig *config = NULL;
static GeglModuleDB *module_db = NULL;
static glong global_time = 0;
static const gchar *makefile (void);
/**
* gegl_init:
* @argc: a pointer to the number of command line arguments.
* @argv: a pointer to the array of command line arguments.
*
* Call this function before using any other GEGL functions. It will initialize
* everything needed to operate GEGL and parses some standard command line
* options. @argc and @argv are adjusted accordingly so your own code will
* never see those standard arguments.
*
* Note that there is an alternative ways to initialize GEGL: if you are
* calling g_option_context_parse() with the option group returned by
* gegl_get_option_group(), you don't have to call gegl_init().
**/
void
gegl_init (gint *argc,
gchar ***argv)
{
GOptionContext *context;
GError *error = NULL;
if (config)
return;
/* If any command-line actions are ever added to GEGL, then the commented
* out code below should be used. Until then, we simply call the parse hook
* directly.
*/
#if 0
gegl_post_parse_hook (NULL, NULL, NULL, NULL);
#else
context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_set_help_enabled (context, FALSE);
g_option_context_set_main_group (context, gegl_get_option_group ());
if (!g_option_context_parse (context, argc, argv, &error))
{
g_warning ("%s", error->message);
g_error_free (error);
}
g_option_context_free (context);
#endif
}
static gchar *cmd_gegl_swap=NULL;
static gchar *cmd_gegl_cache_size=NULL;
static gchar *cmd_gegl_chunk_size=NULL;
static gchar *cmd_gegl_quality=NULL;
static gchar *cmd_gegl_tile_size=NULL;
static gchar *cmd_babl_tolerance =NULL;
static gchar *cmd_gegl_threads=NULL;
static const GOptionEntry cmd_entries[]=
{
{
"babl-tolerance", 0, 0,
G_OPTION_ARG_STRING, &cmd_babl_tolerance,
N_("babls error tolerance, a value beteen 0.2 and 0.000000001"), "<float>"
},
{
"gegl-swap", 0, 0,
G_OPTION_ARG_STRING, &cmd_gegl_swap,
N_("Where GEGL stores it's swap"), "<uri>"
},
{
"gegl-cache-size", 0, 0,
G_OPTION_ARG_STRING, &cmd_gegl_cache_size,
N_("How much memory to (approximately) use for caching imagery"), "<megabytes>"
},
{
"gegl-tile-size", 0, 0,
G_OPTION_ARG_STRING, &cmd_gegl_tile_size,
N_("Default size of tiles in GeglBuffers"), "<widthxheight>"
},
{
"gegl-chunk-size", 0, 0,
G_OPTION_ARG_STRING, &cmd_gegl_chunk_size,
N_("The count of pixels to compute simultaneously"), "pixel count"
},
{
"gegl-quality", 0, 0,
G_OPTION_ARG_STRING, &cmd_gegl_quality,
N_("The quality of rendering a value between 0.0(fast) and 1.0(reference)"), "<quality>"
},
{
"gegl-threads", 0, 0,
G_OPTION_ARG_STRING, &cmd_gegl_threads,
N_("The number of concurrent processing threads to use"), "<threads>"
},
{ NULL }
};
/**
* gegl_get_option_group:
*
* Returns a #GOptionGroup for the commandline arguments recognized
* by GEGL. You should add this group to your #GOptionContext
* with g_option_context_add_group(), if you are using
* g_option_context_parse() to parse your commandline arguments.
*
* Returns a #GOptionGroup for the commandline arguments recognized by GEGL.
*/
GOptionGroup *
gegl_get_option_group (void)
{
GOptionGroup *group;
group = g_option_group_new ("gegl", "GEGL Options", "Show GEGL Options",
NULL, NULL);
g_option_group_add_entries (group, cmd_entries);
g_option_group_set_parse_hooks (group, NULL, gegl_post_parse_hook);
return group;
}
GeglConfig *gegl_config (void)
{
if (!config)
{
config = g_object_new (GEGL_TYPE_CONFIG, NULL);
if (g_getenv ("GEGL_QUALITY"))
config->quality = atof(g_getenv("GEGL_QUALITY"));
if (g_getenv ("GEGL_CACHE_SIZE"))
config->cache_size = atoi(g_getenv("GEGL_CACHE_SIZE"))* 1024*1024;
if (g_getenv ("GEGL_CHUNK_SIZE"))
config->chunk_size = atoi(g_getenv("GEGL_CHUNK_SIZE"));
if (g_getenv ("GEGL_TILE_SIZE"))
{
const gchar *str = g_getenv ("GEGL_TILE_SIZE");
config->tile_width = atoi(str);
str = strchr (str, 'x');
if (str)
config->tile_height = atoi(str+1);
}
if (g_getenv ("GEGL_THREADS"))
{
config->threads = atoi(g_getenv("GEGL_THREADS"));
if (config->threads > GEGL_MAX_THREADS)
{
g_warning ("Tried to use %i threads max is %i",
config->threads, GEGL_MAX_THREADS);
config->threads = GEGL_MAX_THREADS;
}
}
if (g_getenv ("GEGL_USE_OPENCL") != NULL && strcmp(g_getenv ("GEGL_USE_OPENCL"), "yes") == 0)
config->use_opencl = TRUE;
else
config->use_opencl = FALSE;
if (gegl_swap_dir())
config->swap = g_strdup(gegl_swap_dir ());
}
return GEGL_CONFIG (config);
}
void gegl_tile_backend_ram_stats (void);
void gegl_tile_backend_tiledir_stats (void);
void gegl_tile_backend_file_stats (void);
static void swap_clean (void)
{
const gchar *swap_dir = gegl_swap_dir ();
GDir *dir;
if (! swap_dir)
return;
dir = g_dir_open (gegl_swap_dir (), 0, NULL);
if (dir != NULL)
{
GPatternSpec *pattern = g_pattern_spec_new ("*");
const gchar *name;
while ((name = g_dir_read_name (dir)) != NULL)
{
if (g_pattern_match_string (pattern, name))
{
gint readpid = atoi (name);
if (!pid_is_running (readpid))
{
gchar *fname = g_build_filename (gegl_swap_dir (),
name,
NULL);
g_unlink (fname);
g_free (fname);
}
}
}
g_pattern_spec_free (pattern);
g_dir_close (dir);
}
}
void gegl_tile_storage_cache_cleanup (void);
void
gegl_exit (void)
{
glong timing = gegl_ticks ();
gegl_tile_storage_cache_cleanup ();
gegl_tile_cache_destroy ();
gegl_operation_gtype_cleanup ();
gegl_extension_handler_cleanup ();
if (module_db != NULL)
{
g_object_unref (module_db);
module_db = NULL;
}
babl_exit ();
timing = gegl_ticks () - timing;
gegl_instrument ("gegl", "gegl_exit", timing);
/* used when tracking buffer and tile leaks */
if (g_getenv ("GEGL_DEBUG_BUFS") != NULL)
{
gegl_buffer_stats ();
gegl_tile_backend_ram_stats ();
gegl_tile_backend_file_stats ();
gegl_tile_backend_tiledir_stats ();
}
global_time = gegl_ticks () - global_time;
gegl_instrument ("gegl", "gegl", global_time);
if (g_getenv ("GEGL_DEBUG_TIME") != NULL)
{
g_printf ("\n%s", gegl_instrument_utf8 ());
}
if (gegl_buffer_leaks ())
g_printf ("EEEEeEeek! %i GeglBuffers leaked\n", gegl_buffer_leaks ());
gegl_tile_cache_destroy ();
if (gegl_swap_dir ())
{
/* remove all files matching <$GEGL_SWAP>/GEGL-<pid>-*.swap */
guint pid = getpid ();
GDir *dir = g_dir_open (gegl_swap_dir (), 0, NULL);
gchar *glob = g_strdup_printf ("%i-*", pid);
GPatternSpec *pattern = g_pattern_spec_new (glob);
g_free (glob);
if (dir != NULL)
{
const gchar *name;
while ((name = g_dir_read_name (dir)) != NULL)
{
if (g_pattern_match_string (pattern, name))
{
gchar *fname = g_build_filename (gegl_swap_dir (),
name,
NULL);
g_unlink (fname);
g_free (fname);
}
}
g_dir_close (dir);
}
g_pattern_spec_free (pattern);
}
g_object_unref (config);
config = NULL;
}
static void swap_clean (void);
static void
gegl_init_i18n (void)
{
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, GEGL_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
}
void
gegl_get_version (int *major,
int *minor,
int *micro)
{
if (major != NULL)
*major = GEGL_MAJOR_VERSION;
if (minor != NULL)
*minor = GEGL_MINOR_VERSION;
if (micro != NULL)
*micro = GEGL_MICRO_VERSION;
}
static gboolean
gegl_post_parse_hook (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
glong time;
if (config)
return TRUE;
g_assert (global_time == 0);
global_time = gegl_ticks ();
g_type_init ();
gegl_instrument ("gegl", "gegl_init", 0);
config = (void*)gegl_config ();
if (cmd_gegl_swap)
g_object_set (config, "swap", cmd_gegl_swap, NULL);
if (cmd_gegl_quality)
config->quality = atof (cmd_gegl_quality);
if (cmd_gegl_cache_size)
config->cache_size = atoi (cmd_gegl_cache_size)*1024*1024;
if (cmd_gegl_chunk_size)
config->chunk_size = atoi (cmd_gegl_chunk_size);
if (cmd_gegl_tile_size)
{
const gchar *str = cmd_gegl_tile_size;
config->tile_width = atoi(str);
str = strchr (str, 'x');
if (str)
config->tile_height = atoi(str+1);
}
if (cmd_gegl_threads)
config->threads = atoi (cmd_gegl_threads);
if (cmd_babl_tolerance)
g_object_set (config, "babl-tolerance", atof(cmd_babl_tolerance), NULL);
#ifdef GEGL_ENABLE_DEBUG
{
const char *env_string;
env_string = g_getenv ("GEGL_DEBUG");
if (env_string != NULL)
{
gegl_debug_flags =
g_parse_debug_string (env_string,
gegl_debug_keys,
G_N_ELEMENTS (gegl_debug_keys));
env_string = NULL;
}
}
#endif /* GEGL_ENABLE_DEBUG */
time = gegl_ticks ();
babl_init ();
gegl_instrument ("gegl_init", "babl_init", gegl_ticks () - time);
gegl_init_i18n ();
time = gegl_ticks ();
if (!module_db)
{
const gchar *gegl_path = g_getenv ("GEGL_PATH");
module_db = gegl_module_db_new (FALSE);
if (gegl_path)
{
gegl_module_db_load (module_db, gegl_path);
}
else
{
gchar *module_path;
#ifdef G_OS_WIN32
{
gchar *prefix;
prefix = g_win32_get_package_installation_directory_of_module ( hLibGeglModule );
module_path = g_build_filename (prefix, "lib", GEGL_LIBRARY, NULL);
g_free(prefix);
}
#else
module_path = g_build_filename (LIBDIR, GEGL_LIBRARY, NULL);
#endif
gegl_module_db_load (module_db, module_path);
g_free (module_path);
/* also load plug-ins from ~/.local/share/gegl-0.0/plugins */
module_path = g_build_filename (g_get_user_data_dir (),
GEGL_LIBRARY,
"plug-ins",
NULL);
if (g_mkdir_with_parents (module_path,
S_IRUSR | S_IWUSR | S_IXUSR) == 0)
{
gchar *makefile_path = g_build_filename (module_path,
"Makefile",
NULL);
if (! g_file_test (makefile_path, G_FILE_TEST_EXISTS))
g_file_set_contents (makefile_path, makefile (), -1, NULL);
g_free (makefile_path);
}
gegl_module_db_load (module_db, module_path);
g_free (module_path);
}
gegl_instrument ("gegl_init", "load modules", gegl_ticks () - time);
}
gegl_instrument ("gegl", "gegl_init", gegl_ticks () - global_time);
if (g_getenv ("GEGL_SWAP"))
g_object_set (config, "swap", g_getenv ("GEGL_SWAP"), NULL);
if (g_getenv ("GEGL_QUALITY"))
{
const gchar *quality = g_getenv ("GEGL_QUALITY");
if (g_str_equal (quality, "fast"))
g_object_set (config, "quality", 0.0, NULL);
if (g_str_equal (quality, "good"))
g_object_set (config, "quality", 0.5, NULL);
if (g_str_equal (quality, "best"))
g_object_set (config, "quality", 1.0, NULL);
}
swap_clean ();
/* Initialize OpenCL if wanted and possible */
if (gegl_config()->use_opencl)
gegl_cl_init (NULL);
GEGL_NOTE (GEGL_DEBUG_OPENCL, "Using OpenCL: %d\n", gegl_config()->use_opencl && gegl_cl_is_accelerated ());
return TRUE;
}
#ifdef GEGL_ENABLE_DEBUG
#if 0
static gboolean
gegl_arg_debug_cb (const char *key,
const char *value,
gpointer user_data)
{
gegl_debug_flags |=
g_parse_debug_string (value,
gegl_debug_keys,
G_N_ELEMENTS (gegl_debug_keys));
return TRUE;
}
static gboolean
gegl_arg_no_debug_cb (const char *key,
const char *value,
gpointer user_data)
{
gegl_debug_flags &=
~g_parse_debug_string (value,
gegl_debug_keys,
G_N_ELEMENTS (gegl_debug_keys));
return TRUE;
}
#endif
#endif
/*
* gegl_get_debug_enabled:
*
* Check if gegl has debugging turned on.
*
* Return value: TRUE if debugging is turned on, FALSE otherwise.
*/
gboolean
gegl_get_debug_enabled (void)
{
#ifdef GEGL_ENABLE_DEBUG
return gegl_debug_flags != 0;
#else
return FALSE;
#endif
}
static const gchar *makefile (void)
{
return
"# This is a generic makefile for GEGL operations. Just add .c files,\n"
"# rename mentions of the filename and opname to the new name, and it should \n"
"# compile. Operations in this dir should be loaded by GEGL by default\n"
"# If the operation being written depends on extra libraries, you'd better\n"
"# add a dedicated target with the extra bits linked in.\n"
"\n\n"
"CFLAGS += `pkg-config gegl --cflags` -I. -fPIC\n"
"LDFLAGS += `pkg-config gegl --libs` -shared\n"
"SHREXT=.so\n"
"CFILES = $(wildcard ./*.c)\n"
"SOBJS = $(subst ./,,$(CFILES:.c=$(SHREXT)))\n"
"all: $(SOBJS)\n"
"%$(SHREXT): %.c $(GEGLHEADERS)\n"
" @echo $@; $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $< $(LDADD)\n"
"clean:\n"
" rm -f *$(SHREXT) $(OFILES)\n";
}