static gboolean
app_exit_after_callback (Gimp *gimp,
gboolean kill_it,
GMainLoop **loop)
{
if (gimp->be_verbose)
g_print ("EXIT: %s\n", G_STRFUNC);
/*
* In stable releases, we simply call exit() here. This speeds up
* the process of quitting GIMP and also works around the problem
* that plug-ins might still be running.
*
* In unstable releases, we shut down GIMP properly in an attempt
* to catch possible problems in our finalizers.
*/
#ifdef GIMP_UNSTABLE
if (g_main_loop_is_running (*loop))
g_main_loop_quit (*loop);
*loop = NULL;
#else
gegl_exit ();
exit (EXIT_SUCCESS);
#endif
return FALSE;
}
gint
main (gint argc,
gchar **argv)
{
GeglBuffer *buffer;
gegl_init(&argc, &argv);
buffer = test_buffer(1024, 1024, babl_format("RGB float"));
bench("gaussian-blur (RGB)", buffer, &blur);
g_object_unref (buffer);
buffer = test_buffer(1024, 1024, babl_format("RaGaBaA float"));
bench("gaussian-blur (RaGaBaA)", buffer, &blur);
g_object_unref (buffer);
buffer = test_buffer(1024, 1024, babl_format("RGBA float"));
bench("gaussian-blur (RGBA)", buffer, &blur);
g_object_unref (buffer);
buffer = test_buffer(1024, 1024, babl_format("Y float"));
bench("gaussian-blur (Y)", buffer, &blur);
g_object_unref (buffer);
buffer = test_buffer(1024, 1024, babl_format("YaA float"));
bench("gaussian-blur (YaA)", buffer, &blur);
g_object_unref (buffer);
buffer = test_buffer(1024, 1024, babl_format("YA float"));
bench("gaussian-blur (YA)", buffer, &blur);
g_object_unref (buffer);
gegl_exit ();
return 0;
}
int main(int argc, char **argv)
{
gint tests_run = 0;
gint tests_passed = 0;
gint tests_failed = 0;
gegl_init(0, NULL);
g_object_set(G_OBJECT(gegl_config()),
"swap", "RAM",
"use-opencl", FALSE,
NULL);
RUN_TEST (test_buffer_path)
RUN_TEST (test_buffer_path_from_backend)
RUN_TEST (test_buffer_load)
RUN_TEST (test_buffer_same_path)
RUN_TEST (test_buffer_open)
RUN_TEST (test_buffer_change_extent)
gegl_exit();
if (tests_passed == tests_run)
return 0;
return -1;
return 0;
}
gint
main (gint argc,
gchar **argv)
{
GeglBuffer *buffer;
gegl_init (&argc, &argv);
buffer = test_buffer (1024, 1024, babl_format ("RGB float"));
bench ("saturation (RGB)", buffer, &saturation);
g_object_unref (buffer);
buffer = test_buffer (1024, 1024, babl_format ("RGBA float"));
bench ("saturation (RGBA)", buffer, &saturation);
g_object_unref (buffer);
buffer = test_buffer (1024, 1024, babl_format ("CIE Lab float"));
bench ("saturation (CIE Lab)", buffer, &saturation);
g_object_unref (buffer);
buffer = test_buffer (1024, 1024, babl_format ("CIE Lab alpha float"));
bench ("saturation (CIE Lab alpha)", buffer, &saturation);
g_object_unref (buffer);
buffer = test_buffer (1024, 1024, babl_format ("CIE LCH(ab) float"));
bench ("saturation (CIE LCH(ab))", buffer, &saturation);
g_object_unref (buffer);
buffer = test_buffer (1024, 1024, babl_format ("CIE LCH(ab) alpha float"));
bench ("saturation (CIE LCH(ab) alpha)", buffer, &saturation);
g_object_unref (buffer);
gegl_exit ();
return 0;
}
static void
run (const gchar *name,
gint n_params,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 drawable_id;
gint32 image_id;
INIT_I18N ();
gegl_init (NULL, NULL);
*nreturn_vals = 1;
*return_vals = values;
run_mode = param[0].data.d_int32;
if (run_mode == GIMP_RUN_NONINTERACTIVE)
{
if (n_params != 3)
{
status = GIMP_PDB_CALLING_ERROR;
}
}
if (status == GIMP_PDB_SUCCESS)
{
/* Get the specified drawable */
image_id = param[1].data.d_int32;
drawable_id = param[2].data.d_int32;
/* Make sure that the drawable is gray or RGB or indexed */
if (gimp_drawable_is_rgb (drawable_id) ||
gimp_drawable_is_gray (drawable_id) ||
gimp_drawable_is_indexed (drawable_id))
{
gimp_progress_init (_("Zealous cropping"));
do_zcrop (drawable_id, image_id);
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
gegl_exit ();
}
/*
* The purpose of this handler is to exit GIMP cleanly when the batch
* procedure calls the gimp-exit procedure. Without this callback, the
* message "batch command experienced an execution error" would appear
* and gimp would hang forever.
*/
static void
gimp_batch_exit_after_callback (Gimp *gimp)
{
if (gimp->be_verbose)
g_print ("EXIT: %s\n", G_STRFUNC);
gegl_exit ();
exit (EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
gint tests_run = 0;
gint tests_passed = 0;
gint tests_failed = 0;
gint i;
const char *operation_names[] = {
"svg:src",
"svg:dst",
"svg:src-over",
"svg:dst-over",
"svg:src-in",
"svg:dst-in",
"svg:src-out",
"svg:dst-out",
"svg:src-atop",
"svg:dst-atop",
"svg:clear",
"svg:xor",
};
gegl_init(0, NULL);
g_object_set(G_OBJECT(gegl_config()),
"swap", "RAM",
"use-opencl", FALSE,
NULL);
printf ("testing abyss handling of svg blends\n");
for (i = 0; i < G_N_ELEMENTS(operation_names); ++i)
{
if (test_operation (operation_names[i]))
tests_passed++;
else
tests_failed++;
tests_run++;
}
gegl_exit();
printf ("\n");
if (tests_passed == tests_run)
return 0;
return -1;
return 0;
}
int
main(int argc, char **argv)
{
babl_init();
gegl_init(0, NULL);
int retval = mypaint_test_surface_run(argc, argv, gegl_surface_factory, "MyPaintGeglSurface", NULL);
gegl_exit();
return retval;
}
int main(int argc, char **argv)
{
GeglTile *tile;
GeglBuffer *buf_a, *buf_b, *buf_small_lin, *buf_big_lin;
gpointer shared_data = NULL;
gboolean result = TRUE;
gpointer scratch_data;
GeglRectangle buffer_rect = *GEGL_RECTANGLE(0, 0, 128, 128);
gegl_init (&argc, &argv);
buf_a = gegl_buffer_new (&buffer_rect, babl_format("RGBA u8"));
buf_b = gegl_buffer_new (&buffer_rect, babl_format("RGBA u8"));
buf_small_lin = gegl_buffer_linear_new (&buffer_rect, babl_format("RGBA float"));
buf_big_lin = gegl_buffer_linear_new (GEGL_RECTANGLE(0, 0, 1024, 1024), babl_format("RGBA float"));
tile = gegl_tile_source_get_tile (GEGL_TILE_SOURCE (buf_a), 0, 0, 0);
shared_data = gegl_tile_get_data(tile);
gegl_tile_unref (tile);
if (!assert_is_empty (buf_a, 0, 0, shared_data))
result = FALSE;
if (!assert_is_empty (buf_b, 0, 1, shared_data))
result = FALSE;
if (!assert_is_empty (buf_a, 0, 0, shared_data))
result = FALSE;
if (!assert_is_empty (buf_b, 0, 1, shared_data))
result = FALSE;
if (!assert_is_empty (buf_small_lin, 0, 0, shared_data))
result = FALSE;
if (!assert_is_unshared (buf_big_lin, 0, 0, shared_data))
result = FALSE;
scratch_data = gegl_malloc(4 * buffer_rect.width * buffer_rect.height);
gegl_buffer_get (buf_a, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_buffer_get (buf_b, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_buffer_get (buf_small_lin, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_buffer_get (buf_big_lin, &buffer_rect, 1.0, babl_format("RGBA u8"), scratch_data, 0, GEGL_ABYSS_NONE);
gegl_free (scratch_data);
g_object_unref(buf_a);
g_object_unref(buf_b);
g_object_unref(buf_small_lin);
g_object_unref(buf_big_lin);
gegl_exit();
if (result)
return SUCCESS;
return FAILURE;
}
static void
photos_thumbnailer_finalize (GObject *object)
{
PhotosThumbnailer *self = PHOTOS_THUMBNAILER (object);
g_free (self->address);
if (g_application_get_is_registered (G_APPLICATION (self)))
gegl_exit ();
G_OBJECT_CLASS (photos_thumbnailer_parent_class)->finalize (object);
}
gint
main (gint argc,
gchar **argv)
{
GeglNode *gegl, *sink;
if (argc != 4)
{
g_print ("Usage: %s <input image> \"string\" <output image>\n\n", argv[0]);
return -1;
}
g_thread_init (NULL);
gegl_init (&argc, &argv);
gegl =
gegl_graph (
sink = gegl_node ("gegl:png-save", "path", argv[3], NULL,
gegl_node ("gegl:over", NULL,
gegl_node ("gegl:scale",
"x", 0.4,
"y", 0.4,
NULL,
gegl_node ("gegl:invert",
NULL,
gegl_node ("gegl:load",
"path", argv[1],
NULL
))),
gegl_node ("gegl:translate",
"x", 50.0,
"y", 50.0,
NULL,
gegl_node ("gegl:dropshadow",
"opacity", 1.0,
"radius", 3.0,
"x", 3.0,
"y", 3.0,
NULL,
gegl_node ("gegl:text",
"size", 40.0,
"font", "sans bold",
"string", argv[2],
"color", gegl_color_new("green"),
NULL
))))));
gegl_node_process (sink);
g_object_unref (gegl);
gegl_exit ();
return 0;
}
gint
main (gint argc,
gchar **argv)
{
gboolean result;
GError *error = NULL;
GOptionContext *context;
setlocale (LC_ALL, "");
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gegl_get_option_group ());
g_object_set (gegl_config (),
"application-license", "GPL3",
NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printf ("%s\n", error->message);
g_error_free (error);
result = FALSE;
}
else if (output_all && !(data_dir && output_dir))
{
g_printf ("Data and output directories must be specified\n");
result = FALSE;
}
else if (!(output_all || (data_dir && output_dir && reference_dir)))
{
g_printf ("Data, reference and output directories must be specified\n");
result = FALSE;
}
else
{
regex = g_regex_new (pattern, 0, 0, NULL);
exc_regex = g_regex_new (exclusion_pattern, 0, 0, NULL);
result = process_operations (GEGL_TYPE_OPERATION);
g_regex_unref (regex);
g_regex_unref (exc_regex);
}
gegl_exit ();
if (output_all)
return 0;
else
return result;
}
int main(int argc, char *argv[])
{
gint result = SUCCESS;
gegl_init (&argc, &argv);
if (result == SUCCESS)
result = test_buffer_cast ();
gegl_exit ();
return result;
}
/*
* The purpose of this handler is to exit GIMP cleanly when the batch
* procedure calls the gimp-exit procedure. Without this callback, the
* message "batch command experienced an execution error" would appear
* and gimp would hang forever.
*/
static void
batch_exit_after_callback (Gimp *gimp)
{
if (gimp->be_verbose)
g_print ("EXIT: %s\n", G_STRFUNC);
gegl_exit ();
/* make sure that the swap files are removed before we quit */
tile_swap_exit ();
exit (EXIT_SUCCESS);
}
gint
main (gint argc,
gchar **argv)
{
long ticks;
test_start ();
gegl_init (&argc, &argv);
gegl_exit ();
ticks = babl_ticks ()-ticks_start;
g_print ("@ %s: %.2f seconds\n", "init", (ticks / 1000000.0));
return 0;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 drawable_id;
gint x, y, width, height;
*nreturn_vals = 1;
*return_vals = values;
gegl_init (NULL, NULL);
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
INIT_I18N();
drawable_id = param[2].data.d_drawable;
if (gimp_drawable_mask_intersect (drawable_id, &x, &y, &width, &height))
{
GeglBuffer *buffer;
GeglBuffer *shadow_buffer;
buffer = gimp_drawable_get_buffer (drawable_id);
shadow_buffer = gimp_drawable_get_shadow_buffer (drawable_id);
gegl_render_op (buffer, shadow_buffer, "gegl:invert", NULL);
g_object_unref (shadow_buffer); /* flushes the shadow tiles */
g_object_unref (buffer);
gimp_drawable_merge_shadow (drawable_id, TRUE);
gimp_drawable_update (drawable_id, x, y, width, height);
gimp_displays_flush ();
}
values[0].data.d_status = status;
gegl_exit ();
}
int main(int argc, char **argv)
{
gint tests_run = 0;
gint tests_passed = 0;
gint tests_failed = 0;
gdouble scale_list[] = {5.0, 2.5, 2.0, 1.5, 1.0, 0.9, 0.5, 0.3, 0.1, 0.09, 0.05, 0.03};
gint x_list[] = {-16, 0, 15};
gint i, j, k;
gegl_init(0, NULL);
g_object_set(G_OBJECT(gegl_config()),
"swap", "RAM",
"use-opencl", FALSE,
NULL);
printf ("testing scaled blit\n");
for (i = 0; i < sizeof(x_list) / sizeof(x_list[0]); ++i)
{
for (j = 0; j < sizeof(scale_list) / sizeof(scale_list[0]); ++j)
{
const Babl *format_list[] = {babl_format ("RGBA u8"), babl_format ("RGBA u16")};
for (k = 0; k < sizeof(format_list) / sizeof(format_list[0]); ++k)
{
if (test_scale (scale_list[j], x_list[i], 0, format_list[k]))
tests_passed++;
else
tests_failed++;
tests_run++;
}
}
}
gegl_exit();
printf ("\n");
if (tests_passed == tests_run)
return 0;
return -1;
return 0;
}
int main(int argc, char *argv[])
{
gint tests_run = 0;
gint tests_passed = 0;
gint tests_failed = 0;
gegl_init (&argc, &argv);
RUN_TEST (test_convert_001)
RUN_TEST (test_convert_002)
RUN_TEST (test_same_001)
gegl_exit ();
if (tests_passed == tests_run)
return SUCCESS;
return FAILURE;
}
int
main(int argc, char **argv)
{
int retval = -1;
gegl_init(&argc, &argv);
g_test_init(&argc, &argv, NULL);
g_test_add_func("/widgets/view/helper/processing", test_processing);
g_test_add_func("/widgets/view/redraw-basic", test_redraw_basic);
g_test_add_func("/widgets/view/redraw-scaled", test_redraw_scaled);
g_test_add_func("/widgets/view/redraw-translated", test_redraw_translated);
g_test_add_func("/widgets/view/redraw-combined", test_redraw_combined);
retval = g_test_run();
gegl_exit();
return retval;
}
int
main (int argc, char *argv[])
{
int result = -1;
gegl_init(&argc, &argv);
g_test_init(&argc, &argv, NULL);
g_test_add_func("/xml/load/empty_graph", test_load_empty_graph);
g_test_add_func("/xml/load/multiple_nodes", test_load_multiple_nodes);
/* Expected failure: not implemented
g_test_add_func("/xml/load/subgraph", test_load_subgraph);
*/
result = g_test_run();
gegl_exit();
return result;
}
int
main (int argc, char *argv[])
{
int result = -1;
gegl_init(&argc, &argv);
g_test_init(&argc, &argv, NULL);
g_test_add_func("/xml/save/empty_graph", test_save_empty_graph);
g_test_add_func("/xml/save/empty_graph_twice", test_save_empty_graph_twice);
g_test_add_func("/xml/save/only_nop_nodes", test_save_nop_nodes);
g_test_add_func("/xml/save/multiple_nodes", test_save_multiple_nodes);
g_test_add_func("/xml/save/toplevel_graph", test_save_toplevel_graph);
g_test_add_func("/xml/save/segment", test_save_segment);
g_test_add_func("/xml/save/segment_subgraph", test_save_segment_subgraph);
result = g_test_run();
gegl_exit();
return result;
}
gint main (gint argc, gchar **argv)
{
gint i;
gegl_init (&argc, &argv);
for (i=0; i < G_N_ELEMENTS (tests); i++)
{
gchar *ret;
if (argc > 1)
{
/* handle any extra commandline options as a list of tests to
* run and output to standard output
*/
gint j;
for (j=1;j<argc;j++)
{
if (g_str_equal (argv[j], test_names[i]))
{
ret=tests[i]();
printf ("%s", ret);
g_free (ret);
}
}
}
else
{
gchar output_file[1024];
printf ("%s ", test_names[i]);
ret=tests[i]();
sprintf (output_file, "output/%s.buf", test_names[i]);
g_file_set_contents (output_file, ret, -1, NULL);
g_free (ret);
}
}
gegl_exit ();
return 0;
}
int main(int argc, char *argv[])
{
gint tests_run = 0;
gint tests_passed = 0;
gint tests_failed = 0;
gegl_init (&argc, &argv);
RUN_TEST (test_buffer_sink_001)
RUN_TEST (test_opacity_linear_001)
RUN_TEST (test_opacity_linear_002)
RUN_TEST (test_opacity_linear_003)
RUN_TEST (test_opacity_linear_004)
RUN_TEST (test_opacity_gamma_001)
RUN_TEST (test_opacity_gamma_002)
RUN_TEST (test_opacity_gamma_003)
RUN_TEST (test_opacity_gamma_004)
gegl_exit ();
if (tests_passed == tests_run)
return SUCCESS;
return FAILURE;
}
int main(int argc, char **argv)
{
GThread *thread;
gint64 end_time;
gegl_init (&argc, &argv);
thread = g_thread_new (NULL, test, NULL);
end_time = g_get_monotonic_time () + TIMEOUT;
g_mutex_lock (&mutex);
while (! finished)
{
if (! g_cond_wait_until (&cond, &mutex, end_time))
break;
}
g_mutex_unlock (&mutex);
if (finished)
{
g_thread_join (thread);
gegl_exit ();
return SUCCESS;
}
else
{
g_print ("timeout expired. failing.\n");
return FAILURE;
}
}
int main(int argc , char **argv)
{
GeglNode *load, *laplace, *gegl, *write;
gegl_init (&argc, &argv);
if(argv[1]==NULL || argv[2]==NULL)
{
g_print ("\nEdge Detection using GEGL Operation.");
g_print ("\nUsage: %s <input-image> <output-image>\n", argv[0]);
return 1;
}
gegl = gegl_node_new ();
load = gegl_node_new_child (gegl,
"operation", "gegl:load",
"path", argv[1],
NULL);
laplace = gegl_node_new_child (gegl,
"operation", "gegl:edge-laplace",
NULL);
write = gegl_node_new_child (gegl,
"operation", "gegl:save",
"path", argv[2],
NULL);
gegl_node_link_many (load, laplace, write, NULL);
gegl_node_process (write);
g_object_unref (gegl);
gegl_exit();
return 0;
}
int main(int argc, char *argv[])
{
gint result = SUCCESS;
GeglRectangle rect1 = { 0, 0, 1, 1 };
GeglRectangle rect2 = { 1, 0, 1, 1 };
GeglRectangle rect3 = { 1, 1, 1, 1 };
GeglRectangle rect4 = { 0, 1, 1, 1 };
GeglColor *color_white = NULL;
GeglColor *color_black = NULL;
GeglNode *gegl = NULL;
GeglNode *white = NULL;
GeglNode *translate = NULL;
GeglNode *over = NULL;
GeglNode *black = NULL;
GeglNode *crop = NULL;
GeglNode *sink = NULL;
GeglProcessor *processor = NULL;
/* Convenient line to keep around:
g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL);
*/
gegl_init (&argc, &argv);
color_white = gegl_color_new ("rgb(1.0, 1.0, 1.0)");
color_black = gegl_color_new ("rgb(0.0, 0.0, 0.0)");
gegl = gegl_node_new ();
white = gegl_node_new_child (gegl,
"operation", "gegl:color",
"value", color_white,
NULL);
translate = gegl_node_new_child (gegl,
"operation", "gegl:translate",
"x", -50.0,
"y", -20.0,
NULL);
over = gegl_node_new_child (gegl,
"operation", "gegl:over",
NULL);
black = gegl_node_new_child (gegl,
"operation", "gegl:color",
"value", color_black,
NULL);
crop = gegl_node_new_child (gegl,
"operation", "gegl:crop",
"x", 10.0,
"y", 10.0,
"width", 100.0,
"height", 100.0,
NULL);
sink = gegl_node_new_child (gegl,
"operation", "gegl:buffer-sink",
NULL);
/* We build our graph for processing complexity, not for compositing
* complexity
*/
gegl_node_link_many (black, over, sink, NULL);
gegl_node_link_many (white, crop, translate, NULL);
gegl_node_connect_to (translate, "output", over, "aux");
/* Create a processor */
processor = gegl_node_new_processor (sink, NULL);
/* Do the tests */
if (!test_change_processor_rect_do_test (processor, &rect1, sink))
{
g_printerr ("test-change-processor-rect: First compare failed\n");
result = FAILURE;
goto abort;
}
if (!test_change_processor_rect_do_test (processor, &rect2, sink))
{
g_printerr ("test-change-processor-rect: Second compare failed\n");
result = FAILURE;
goto abort;
}
if (!test_change_processor_rect_do_test (processor, &rect3, sink))
{
g_printerr ("test-change-processor-rect: Third compare failed\n");
result = FAILURE;
goto abort;
}
if (!test_change_processor_rect_do_test (processor, &rect4, sink))
{
g_printerr ("test-change-processor-rect: Fourth compare failed\n");
result = FAILURE;
goto abort;
}
/* Cleanup */
abort:
g_object_unref (processor);
g_object_unref (color_white);
g_object_unref (color_black);
g_object_unref (gegl);
gegl_exit ();
return result;
}
void
app_run (const gchar *full_prog_name,
const gchar **filenames,
const gchar *alternate_system_gimprc,
const gchar *alternate_gimprc,
const gchar *session_name,
const gchar *batch_interpreter,
const gchar **batch_commands,
gboolean as_new,
gboolean no_interface,
gboolean no_data,
gboolean no_fonts,
gboolean no_splash,
gboolean be_verbose,
gboolean use_shm,
gboolean use_cpu_accel,
gboolean console_messages,
gboolean use_debug_handler,
GimpStackTraceMode stack_trace_mode,
GimpPDBCompatMode pdb_compat_mode)
{
GimpInitStatusFunc update_status_func = NULL;
Gimp *gimp;
GMainLoop *loop;
GMainLoop *run_loop;
gchar *default_folder = NULL;
if (filenames && filenames[0] && ! filenames[1] &&
g_file_test (filenames[0], G_FILE_TEST_IS_DIR))
{
if (g_path_is_absolute (filenames[0]))
{
default_folder = g_filename_to_uri (filenames[0], NULL, NULL);
}
else
{
gchar *absolute = g_build_path (G_DIR_SEPARATOR_S,
g_get_current_dir (),
filenames[0],
NULL);
default_folder = g_filename_to_uri (absolute, NULL, NULL);
g_free (absolute);
}
filenames = NULL;
}
/* Create an instance of the "Gimp" object which is the root of the
* core object system
*/
gimp = gimp_new (full_prog_name,
session_name,
default_folder,
be_verbose,
no_data,
no_fonts,
no_interface,
use_shm,
use_cpu_accel,
console_messages,
stack_trace_mode,
pdb_compat_mode);
gimp_cpu_accel_set_use (use_cpu_accel);
errors_init (gimp, full_prog_name, use_debug_handler, stack_trace_mode);
units_init (gimp);
/* Check if the user's gimp_directory exists
*/
if (! g_file_test (gimp_directory (), G_FILE_TEST_IS_DIR))
{
GimpUserInstall *install = gimp_user_install_new (be_verbose);
#ifdef GIMP_CONSOLE_COMPILATION
gimp_user_install_run (install);
#else
if (! (no_interface ?
gimp_user_install_run (install) :
user_install_dialog_run (install)))
exit (EXIT_FAILURE);
#endif
gimp_user_install_free (install);
}
gimp_load_config (gimp, alternate_system_gimprc, alternate_gimprc);
/* change the locale if a language if specified */
language_init (gimp->config->language);
/* initialize lowlevel stuff */
gimp_gegl_init (gimp);
#ifndef GIMP_CONSOLE_COMPILATION
if (! no_interface)
update_status_func = gui_init (gimp, no_splash);
#endif
if (! update_status_func)
update_status_func = app_init_update_noop;
/* Create all members of the global Gimp instance which need an already
* parsed gimprc, e.g. the data factories
*/
gimp_initialize (gimp, update_status_func);
/* Load all data files
*/
gimp_restore (gimp, update_status_func);
/* enable autosave late so we don't autosave when the
* monitor resolution is set in gui_init()
*/
gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), TRUE);
loop = run_loop = g_main_loop_new (NULL, FALSE);
g_signal_connect_after (gimp, "exit",
G_CALLBACK (app_exit_after_callback),
&run_loop);
/* Load the images given on the command-line.
*/
if (filenames)
{
gint i;
for (i = 0; filenames[i] != NULL; i++)
{
if (run_loop)
file_open_from_command_line (gimp, filenames[i], as_new);
}
}
if (run_loop)
batch_run (gimp, batch_interpreter, batch_commands);
if (run_loop)
{
gimp_threads_leave (gimp);
g_main_loop_run (loop);
gimp_threads_enter (gimp);
}
g_main_loop_unref (loop);
g_object_unref (gimp);
gimp_debug_instances ();
errors_exit ();
gegl_exit ();
}
gint
main (gint argc,
gchar **argv)
{
GeglRectangle terrain_rect;
if (argc < 2)
usage();
gegl_init (&argc, &argv);
parse_args (argc, argv);
gegl_decode = gegl_node_new ();
store = gegl_node_new_child (gegl_decode,
"operation", "gegl:buffer-sink",
"buffer", &video_frame, NULL);
load = gegl_node_new_child (gegl_decode,
"operation", "gegl:ff-load",
"frame", 0,
"path", video_path,
NULL);
gegl_node_link_many (load, store, NULL);
decode_frame_no (0); /* we issue a processing/decoding of a frame - to get metadata */
{
gegl_node_get (load, "frame-rate", &frame_rate, NULL);
total_frames = 0; gegl_node_get (load, "frames", &total_frames, NULL);
if (frame_end == 0)
frame_end = total_frames;
}
if (horizontal)
terrain_rect = (GeglRectangle){0, 0,
frame_end - frame_start + 1,
1024};
else
terrain_rect = (GeglRectangle){0, 0,
1024,
frame_end - frame_start + 1};
if (input_analysis_path && g_file_test (input_analysis_path, G_FILE_TEST_IS_REGULAR))
{
GeglNode *load_graph = gegl_node_new ();
GeglNode *load = gegl_node_new_child (load_graph, "operation", "gegl:load", "path", input_analysis_path, NULL);
GeglNode *store = gegl_node_new_child (load_graph, "operation",
"gegl:buffer-sink",
"buffer", &terrain, NULL);
gegl_node_link_many (load, store, NULL);
gegl_node_process (store);
g_object_unref (load_graph);
frame_end = frame_start + gegl_buffer_get_extent (terrain)->height;
/* the last frame aavilavle for analysis is the last one loaded rom cache,.. perhaps with some timeout */
}
else
{
terrain = gegl_buffer_new (&terrain_rect, babl_format ("RGBA u8"));
{
gint frame;
gint max_buf_pos = 0;
for (frame = frame_start; frame <= frame_end; frame++)
{
FrameInfo info = {{0}};
uint8_t buffer[4096] = {0,};
int buffer_pos = 0;
GeglRectangle terrain_row;
char *p = format;
GString *word = g_string_new ("");
if (show_progress)
{
double percent_full = 100.0 * (frame-frame_start) / (frame_end-frame_start);
double percent_time = time_out?100.0 * babl_ticks()/1000.0/1000.0 / time_out:0.0;
fprintf (stdout, "\r%2.1f%% %i/%i (%i)",
percent_full>percent_time?percent_full:percent_time,
frame-frame_start,
frame_end-frame_start,
frame);
fflush (stdout);
}
if (horizontal)
terrain_row = (GeglRectangle){frame-frame_start, 0, 1, 1024};
else
terrain_row = (GeglRectangle){0, frame-frame_start, 1024, 1};
decode_frame_no (frame);
//for (int i=0;i<(signed)sizeof(buffer);i++)buffer[i]=0;
while (*p == ' ') p++;
for (p= format;p==format || p[-1]!='\0';p++)
{
if (*p != '\0' && *p != ' ')
{
g_string_append_c (word, *p);
}
else
{
if (!strcmp (word->str, "histogram"))
{
record_pix_stats (video_frame, previous_video_frame,
&(info.rgb_hist[0]),
&(info.rgb_square_diff)[0]);
for (int i = 0; i < NEGL_RGB_HIST_SLOTS; i++)
{
buffer[buffer_pos] = info.rgb_hist[i];
buffer_pos++;
}
for (int i = 0; i < 3; i++)
{
buffer[buffer_pos] = info.rgb_square_diff[i];
buffer_pos++;
}
}
else if (!strcmp (word->str, "mid-row"))
{
int samples = NEGL_RGB_HEIGHT;
if (p[1] >= '0' && p[1] <= '9')
{
samples = g_strtod (&p[1], &p);
}
buffer_pos += extract_mid_row (video_frame, &(buffer)[buffer_pos], samples);
}
else if (!strcmp (word->str, "mid-col"))
{
int samples = NEGL_RGB_HEIGHT;
if (p[1] >= '0' && p[1] <= '9')
{
samples = g_strtod (&p[1], &p);
}
buffer_pos += extract_mid_col (video_frame, &(buffer)[buffer_pos], samples);
}
else if (!strcmp (word->str, "thumb"))
{
int samples = NEGL_RGB_THEIGHT;
int samples2;
if (p[1] >= '0' && p[1] <= '9')
{
samples = g_strtod (&p[1], &p);
}
if (horizontal)
samples2 = samples * gegl_buffer_get_width (video_frame)/gegl_buffer_get_height(video_frame);
else
samples2 = samples * gegl_buffer_get_height (video_frame)/gegl_buffer_get_width(video_frame);
buffer_pos += extract_thumb (video_frame, &(buffer)[buffer_pos], samples, samples2);
}
else if (!strcmp (word->str, "audio"))
{
int dups = 1;
GeglAudioFragment *audio = NULL;
if (p[1] >= '0' && p[1] <= '9')
{
dups = g_strtod (&p[1], &p);
}
gegl_node_get (load, "audio", &audio, NULL);
if (audio)
{
extract_audio_energy (audio, &buffer[buffer_pos], dups);
g_object_unref (audio);
}
buffer_pos+=3 * dups;
}
g_string_assign (word, "");
}
}
max_buf_pos = buffer_pos;
g_string_free (word, TRUE);
gegl_buffer_set (terrain, &terrain_row, 0, babl_format("RGB u8"),
buffer,
GEGL_AUTO_ROWSTRIDE);
if (time_out > 1.0 &&
babl_ticks()/1000.0/1000.0 > time_out)
{
frame_end = frame;
if (horizontal)
terrain_rect.width = frame_end - frame_start + 1;
else
terrain_rect.height = frame_end - frame_start + 1;
// gegl_buffer_set_extent (terrain, &terrain_rect);
}
if (horizontal)
terrain_rect.height = max_buf_pos/3;
else
terrain_rect.width = max_buf_pos/3;
gegl_buffer_set_extent (terrain, &terrain_rect);
}
if (show_progress)
{
fprintf (stdout, "\n");
fflush (stdout);
}
}
if (output_analysis_path)
{
GeglNode *save_graph = gegl_node_new ();
GeglNode *readbuf = gegl_node_new_child (save_graph, "operation", "gegl:buffer-source", "buffer", terrain, NULL);
GeglNode *save = gegl_node_new_child (save_graph, "operation", "gegl:png-save",
"path", output_analysis_path, NULL);
gegl_node_link_many (readbuf, save, NULL);
gegl_node_process (save);
g_object_unref (save_graph);
}
}
if (thumb_path)
{
GeglNode *save_graph = gegl_node_new ();
find_best_thumb ();
if (frame_thumb != 0)
decode_frame_no (frame_thumb-1);
decode_frame_no (frame_thumb);
{
GeglNode *readbuf = gegl_node_new_child (save_graph, "operation", "gegl:buffer-source", "buffer", video_frame, NULL);
GeglNode *save = gegl_node_new_child (save_graph, "operation", "gegl:png-save",
"path", thumb_path, NULL);
gegl_node_link_many (readbuf, save, NULL);
gegl_node_process (save);
g_object_unref (save_graph);
}
}
if (video_frame)
g_object_unref (video_frame);
video_frame = NULL;
if (previous_video_frame)
g_object_unref (previous_video_frame);
previous_video_frame = NULL;
if (terrain)
g_object_unref (terrain);
terrain = NULL;
g_object_unref (gegl_decode);
gegl_exit ();
return 0;
}
void dt_cleanup()
{
const int init_gui = (darktable.gui != NULL);
#ifdef USE_LUA
dt_lua_finalize();
#endif
if(init_gui)
{
dt_ctl_switch_mode_to(DT_MODE_NONE);
dt_dbus_destroy(darktable.dbus);
dt_control_write_config(darktable.control);
dt_control_shutdown(darktable.control);
dt_lib_cleanup(darktable.lib);
free(darktable.lib);
}
dt_view_manager_cleanup(darktable.view_manager);
free(darktable.view_manager);
if(init_gui)
{
dt_imageio_cleanup(darktable.imageio);
free(darktable.imageio);
dt_gui_gtk_cleanup(darktable.gui);
free(darktable.gui);
}
dt_image_cache_cleanup(darktable.image_cache);
free(darktable.image_cache);
dt_mipmap_cache_cleanup(darktable.mipmap_cache);
free(darktable.mipmap_cache);
if(init_gui)
{
dt_control_cleanup(darktable.control);
free(darktable.control);
dt_undo_cleanup(darktable.undo);
}
dt_conf_cleanup(darktable.conf);
free(darktable.conf);
dt_points_cleanup(darktable.points);
free(darktable.points);
dt_iop_unload_modules_so();
dt_opencl_cleanup(darktable.opencl);
free(darktable.opencl);
#ifdef HAVE_GPHOTO2
dt_camctl_destroy(darktable.camctl);
#endif
dt_pwstorage_destroy(darktable.pwstorage);
dt_fswatch_destroy(darktable.fswatch);
#ifdef HAVE_GRAPHICSMAGICK
DestroyMagick();
#endif
dt_database_destroy(darktable.db);
dt_bauhaus_cleanup();
dt_capabilities_cleanup();
dt_pthread_mutex_destroy(&(darktable.db_insert));
dt_pthread_mutex_destroy(&(darktable.plugin_threadsafe));
dt_pthread_mutex_destroy(&(darktable.capabilities_threadsafe));
dt_exif_cleanup();
#ifdef HAVE_GEGL
gegl_exit();
#endif
}
gint
main (gint argc,
gchar **argv)
{
g_thread_init (NULL);
gtk_init (&argc, &argv);
gegl_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GEGL destructive painter");
if (argv[1] == NULL)
{
GeglRectangle rect = {0, 0, 512, 512};
gpointer buf;
/* XXX: for best overall performance, this format should probably
* be RaGaBaA float, overeager in-place processing code makes that fail though.
*/
buffer = gegl_buffer_new (&rect, babl_format("R'G'B' u8"));
/* it would be useful to have a programmatic way of doing this, filling
* with a given pixel value
*/
buf = gegl_buffer_linear_open (buffer, NULL, NULL, babl_format ("Y' u8"));
memset (buf, 255, 512 * 512);
gegl_buffer_linear_close (buffer, buf);
}
else
{
buffer = gegl_buffer_open (argv[1]);
}
gegl = gegl_node_new ();
{
GeglNode *loadbuf = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", buffer, NULL);
out = gegl_node_new_child (gegl, "operation", "gegl:nop", NULL);
gegl_node_link_many (loadbuf, out, NULL);
view = g_object_new (GEGL_TYPE_VIEW, "node", out, NULL);
top = loadbuf;
}
g_signal_connect (GTK_OBJECT (view), "motion-notify-event",
(GCallback) paint_motion, NULL);
g_signal_connect (GTK_OBJECT (view), "button-press-event",
(GCallback) paint_press, NULL);
g_signal_connect (GTK_OBJECT (view), "button-release-event",
(GCallback) paint_release, NULL);
gtk_widget_add_events (view, GDK_BUTTON_RELEASE_MASK);
gtk_container_add (GTK_CONTAINER (window), view);
gtk_widget_set_size_request (view, 512, 512);
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (gtk_main_quit), window);
gtk_widget_show_all (window);
gtk_main ();
g_object_unref (gegl);
gegl_buffer_destroy (buffer);
gegl_exit ();
return 0;
}
