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; }