2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3 * 2000 Wim Taymans <wtay@chello.be>
5 * gst.c: Initialization and non-pipeline operations
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
25 * @short_description: Media library supporting arbitrary formats and filter
27 * @see_also: Check out both <ulink url="http://www.cse.ogi.edu/sysl/">OGI's
28 * pipeline</ulink> and Microsoft's DirectShow for some background.
30 * GStreamer is a framework for constructing graphs of various filters
31 * (termed elements here) that will handle streaming media. Any discreet
32 * (packetizable) media type is supported, with provisions for automatically
33 * determining source type. Formatting/framing information is provided with
34 * a powerful negotiation framework. Plugins are heavily used to provide for
35 * all elements, allowing one to construct plugins outside of the GST
36 * library, even released binary-only if license require (please don't).
38 * GStreamer borrows heavily from both the <ulink
39 * url="http://www.cse.ogi.edu/sysl/">OGI media pipeline</ulink> and
40 * Microsoft's DirectShow, hopefully taking the best of both and leaving the
41 * cruft behind. Its interface is slowly getting stable.
43 * The <application>GStreamer</application> library should be initialized with
44 * gst_init() before it can be used. You should pass pointers to the main argc
45 * and argv variables so that GStreamer can process its own command line
46 * options, as shown in the following example.
49 * <title>Initializing the gstreamer library</title>
50 * <programlisting language="c">
52 * main (int argc, char *argv[])
54 * // initialize the GStreamer library
55 * gst_init (&argc, &argv);
61 * It's allowed to pass two NULL pointers to gst_init() in case you don't want
62 * to pass the command line args to GStreamer.
64 * You can also use GOption to initialize your own parameters as shown in
65 * the next code fragment:
67 * <title>Initializing own parameters when initializing gstreamer</title>
69 * static gboolean stats = FALSE;
72 * main (int argc, char *argv[])
74 * GOptionEntry options[] = {
75 * {"tags", 't', 0, G_OPTION_ARG_NONE, &tags,
76 * N_("Output tags (also known as metadata)"), NULL},
79 * // must initialise the threading system before using any other GLib funtion
80 * if (!g_thread_supported ())
81 * g_thread_init (NULL);
82 * ctx = g_option_context_new ("[ADDITIONAL ARGUMENTS]");
83 * g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
84 * g_option_context_add_group (ctx, gst_init_get_option_group ());
85 * if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
86 * g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));
89 * g_option_context_free (ctx);
95 * Use gst_version() to query the library version at runtime or use the
96 * GST_VERSION_* macros to find the version at compile time. Optionally
97 * gst_version_string() returns a printable string.
99 * The gst_deinit() call is used to clean up all internal resources used
100 * by <application>GStreamer</application>. It is mostly used in unit tests
101 * to check for leaks.
103 * Last reviewed on 2006-08-11 (0.10.10)
106 #include "gstconfig.h"
108 #include "gst_private.h"
111 #include <sys/types.h>
113 #include <sys/wait.h>
114 #endif /* HAVE_FORK */
115 #ifdef HAVE_SYS_UTSNAME_H
116 #include <sys/utsname.h>
122 #include "gst-i18n-lib.h"
123 #include <locale.h> /* for LC_ALL */
127 #define GST_CAT_DEFAULT GST_CAT_GST_INIT
129 #define MAX_PATH_SPLIT 16
130 #define GST_PLUGIN_SEPARATOR ","
132 static gboolean gst_initialized = FALSE;
133 static gboolean gst_deinitialized = FALSE;
135 #ifndef GST_DISABLE_REGISTRY
136 static GList *plugin_paths = NULL; /* for delayed processing in post_init */
139 #ifndef GST_DISABLE_GST_DEBUG
140 extern const gchar *priv_gst_dump_dot_dir;
144 #if defined(HAVE_FORK) && !defined(GST_HAVE_UNSAFE_FORK)
145 #define DEFAULT_FORK TRUE
147 #define DEFAULT_FORK FALSE
148 #endif /* HAVE_FORK */
150 /* set to TRUE when segfaults need to be left as is */
151 static gboolean _gst_disable_segtrap = FALSE;
153 /* control the behaviour of registry rebuild */
154 static gboolean _gst_enable_registry_fork = DEFAULT_FORK;
156 /*set to TRUE when registry needn't to be updated */
157 static gboolean _gst_disable_registry_update = FALSE;
159 static void load_plugin_func (gpointer data, gpointer user_data);
160 static gboolean init_pre (GOptionContext * context, GOptionGroup * group,
161 gpointer data, GError ** error);
162 static gboolean init_post (GOptionContext * context, GOptionGroup * group,
163 gpointer data, GError ** error);
164 #ifndef GST_DISABLE_OPTION_PARSING
165 static gboolean parse_goption_arg (const gchar * s_opt,
166 const gchar * arg, gpointer data, GError ** err);
169 static GSList *preload_plugins = NULL;
171 const gchar g_log_domain_gstreamer[] = "GStreamer";
174 debug_log_handler (const gchar * log_domain,
175 GLogLevelFlags log_level, const gchar * message, gpointer user_data)
177 g_log_default_handler (log_domain, log_level, message, user_data);
178 /* FIXME: do we still need this ? fatal errors these days are all
179 * other than core errors */
180 /* g_on_error_query (NULL); */
187 #ifndef GST_DISABLE_GST_DEBUG
198 ARG_REGISTRY_UPDATE_DISABLE,
199 ARG_REGISTRY_FORK_DISABLE
202 /* debug-spec ::= category-spec [, category-spec]*
203 * category-spec ::= category:val | val
212 #ifndef GST_DISABLE_GST_DEBUG
214 parse_debug_category (gchar * str, const gchar ** category)
231 parse_debug_level (gchar * str, gint * level)
239 if (str[0] != NUL && str[1] == NUL
240 && str[0] >= '0' && str[0] < '0' + GST_LEVEL_COUNT) {
241 *level = str[0] - '0';
249 parse_debug_list (const gchar * list)
254 g_return_if_fail (list != NULL);
256 split = g_strsplit (list, ",", 0);
258 for (walk = split; *walk; walk++) {
259 if (strchr (*walk, ':')) {
260 gchar **values = g_strsplit (*walk, ":", 2);
262 if (values[0] && values[1]) {
264 const gchar *category;
266 if (parse_debug_category (values[0], &category)
267 && parse_debug_level (values[1], &level))
268 gst_debug_set_threshold_for_name (category, level);
275 if (parse_debug_level (*walk, &level))
276 gst_debug_set_default_threshold (level);
285 * gst_init_get_option_group:
287 * Returns a #GOptionGroup with GStreamer's argument specifications. The
288 * group is set up to use standard GOption callbacks, so when using this
289 * group in combination with GOption parsing methods, all argument parsing
290 * and initialization is automated.
292 * This function is useful if you want to integrate GStreamer with other
293 * libraries that use GOption (see g_option_context_add_group() ).
295 * If you use this function, you should make sure you initialise the GLib
296 * threading system as one of the very first things in your program
297 * (see the example at the beginning of this section).
299 * Returns: a pointer to GStreamer's option group.
303 gst_init_get_option_group (void)
305 #ifndef GST_DISABLE_OPTION_PARSING
307 static const GOptionEntry gst_args[] = {
308 {"gst-version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
309 (gpointer) parse_goption_arg, N_("Print the GStreamer version"), NULL},
310 {"gst-fatal-warnings", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
311 (gpointer) parse_goption_arg, N_("Make all warnings fatal"), NULL},
312 #ifndef GST_DISABLE_GST_DEBUG
313 {"gst-debug-help", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
314 (gpointer) parse_goption_arg,
315 N_("Print available debug categories and exit"),
317 {"gst-debug-level", 0, 0, G_OPTION_ARG_CALLBACK,
318 (gpointer) parse_goption_arg,
319 N_("Default debug level from 1 (only error) to 5 (anything) or "
322 {"gst-debug", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) parse_goption_arg,
323 N_("Comma-separated list of category_name:level pairs to set "
324 "specific levels for the individual categories. Example: "
325 "GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
327 {"gst-debug-no-color", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
328 (gpointer) parse_goption_arg, N_("Disable colored debugging output"),
330 {"gst-debug-disable", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
331 (gpointer) parse_goption_arg, N_("Disable debugging"), NULL},
333 {"gst-plugin-spew", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
334 (gpointer) parse_goption_arg,
335 N_("Enable verbose plugin loading diagnostics"),
337 {"gst-plugin-path", 0, 0, G_OPTION_ARG_CALLBACK,
338 (gpointer) parse_goption_arg,
339 N_("Colon-separated paths containing plugins"), N_("PATHS")},
340 {"gst-plugin-load", 0, 0, G_OPTION_ARG_CALLBACK,
341 (gpointer) parse_goption_arg,
342 N_("Comma-separated list of plugins to preload in addition to the "
343 "list stored in environment variable GST_PLUGIN_PATH"),
345 {"gst-disable-segtrap", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
346 (gpointer) parse_goption_arg,
347 N_("Disable trapping of segmentation faults during plugin loading"),
349 {"gst-disable-registry-update", 0, G_OPTION_FLAG_NO_ARG,
350 G_OPTION_ARG_CALLBACK,
351 (gpointer) parse_goption_arg,
352 N_("Disable updating the registry"),
354 {"gst-disable-registry-fork", 0, G_OPTION_FLAG_NO_ARG,
355 G_OPTION_ARG_CALLBACK,
356 (gpointer) parse_goption_arg,
357 N_("Disable the use of fork() while scanning the registry"),
362 /* The GLib threading system must be initialised before calling any other
363 * GLib function according to the documentation; if the application hasn't
364 * called gst_init() yet or initialised the threading system otherwise, we
365 * better issue a warning here (since chances are high that the application
366 * has already called other GLib functions such as g_option_context_new() */
367 if (!g_thread_supported ()) {
368 g_warning ("The GStreamer function gst_init_get_option_group() was\n"
369 "\tcalled, but the GLib threading system has not been initialised\n"
370 "\tyet, something that must happen before any other GLib function\n"
371 "\tis called. The application needs to be fixed so that it calls\n"
372 "\t if (!g_thread_supported ()) g_thread_init(NULL);\n"
373 "\tas very first thing in its main() function. Please file a bug\n"
374 "\tagainst this application.");
375 g_thread_init (NULL);
378 group = g_option_group_new ("gst", _("GStreamer Options"),
379 _("Show GStreamer Options"), NULL, NULL);
380 g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,
381 (GOptionParseFunc) init_post);
383 g_option_group_add_entries (group, gst_args);
384 g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
394 * @argc: pointer to application's argc
395 * @argv: pointer to application's argv
396 * @err: pointer to a #GError to which a message will be posted on error
398 * Initializes the GStreamer library, setting up internal path lists,
399 * registering built-in elements, and loading standard plugins.
401 * This function will return %FALSE if GStreamer could not be initialized
402 * for some reason. If you want your program to fail fatally,
403 * use gst_init() instead.
405 * This function should be called before calling any other GLib functions. If
406 * this is not an option, your program must initialise the GLib thread system
407 * using g_thread_init() before any other GLib functions are called.
409 * Returns: %TRUE if GStreamer could be initialized.
412 gst_init_check (int *argc, char **argv[], GError ** err)
414 #ifndef GST_DISABLE_OPTION_PARSING
420 if (!g_thread_supported ())
421 g_thread_init (NULL);
423 if (gst_initialized) {
424 GST_DEBUG ("already initialized gst");
427 #ifndef GST_DISABLE_OPTION_PARSING
428 ctx = g_option_context_new ("- GStreamer initialization");
429 g_option_context_set_ignore_unknown_options (ctx, TRUE);
430 group = gst_init_get_option_group ();
431 g_option_context_add_group (ctx, group);
432 res = g_option_context_parse (ctx, argc, argv, err);
433 g_option_context_free (ctx);
435 init_pre (NULL, NULL, NULL, NULL);
436 init_post (NULL, NULL, NULL, NULL);
440 gst_initialized = res;
443 GST_INFO ("initialized GStreamer successfully");
445 GST_INFO ("failed to initialize GStreamer");
453 * @argc: pointer to application's argc
454 * @argv: pointer to application's argv
456 * Initializes the GStreamer library, setting up internal path lists,
457 * registering built-in elements, and loading standard plugins.
459 * This function should be called before calling any other GLib functions. If
460 * this is not an option, your program must initialise the GLib thread system
461 * using g_thread_init() before any other GLib functions are called.
464 * This function will terminate your program if it was unable to initialize
465 * GStreamer for some reason. If you want your program to fall back,
466 * use gst_init_check() instead.
469 * WARNING: This function does not work in the same way as corresponding
470 * functions in other glib-style libraries, such as gtk_init(). In
471 * particular, unknown command line options cause this function to
472 * abort program execution.
475 gst_init (int *argc, char **argv[])
479 if (!gst_init_check (argc, argv, &err)) {
480 g_print ("Could not initialize GStreamer: %s\n",
481 err ? err->message : "unknown error occurred");
489 #ifndef GST_DISABLE_REGISTRY
491 add_path_func (gpointer data, gpointer user_data)
493 GST_INFO ("Adding plugin path: \"%s\", will scan later", (gchar *) data);
494 plugin_paths = g_list_append (plugin_paths, g_strdup (data));
498 #ifndef GST_DISABLE_OPTION_PARSING
500 prepare_for_load_plugin_func (gpointer data, gpointer user_data)
502 preload_plugins = g_slist_prepend (preload_plugins, g_strdup (data));
507 load_plugin_func (gpointer data, gpointer user_data)
510 const gchar *filename;
513 filename = (const gchar *) data;
515 plugin = gst_plugin_load_file (filename, &err);
518 GST_INFO ("Loaded plugin: \"%s\"", filename);
520 gst_default_registry_add_plugin (plugin);
523 /* Report error to user, and free error */
524 GST_ERROR ("Failed to load plugin: %s", err->message);
527 GST_WARNING ("Failed to load plugin: \"%s\"", filename);
532 #ifndef GST_DISABLE_OPTION_PARSING
534 split_and_iterate (const gchar * stringlist, gchar * separator, GFunc iterator,
539 gchar *lastlist = g_strdup (stringlist);
542 strings = g_strsplit (lastlist, separator, MAX_PATH_SPLIT);
547 iterator (strings[j], user_data);
548 if (++j == MAX_PATH_SPLIT) {
549 lastlist = g_strdup (strings[j]);
554 g_strfreev (strings);
559 /* we have no fail cases yet, but maybe in the future */
561 init_pre (GOptionContext * context, GOptionGroup * group, gpointer data,
564 if (gst_initialized) {
565 GST_DEBUG ("already initialized");
569 /* GStreamer was built against a GLib >= 2.8 and is therefore not doing
570 * the refcount hack. Check that it isn't being run against an older GLib */
571 if (glib_major_version < 2 ||
572 (glib_major_version == 2 && glib_minor_version < 8)) {
573 g_warning ("GStreamer was compiled against GLib %d.%d.%d but is running"
574 " against %d.%d.%d. This will cause reference counting issues",
575 GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION,
576 glib_major_version, glib_minor_version, glib_micro_version);
581 /* we need threading to be enabled right here */
582 g_assert (g_thread_supported ());
586 setlocale (LC_ALL, "");
587 bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
588 bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
589 #endif /* ENABLE_NLS */
591 #ifndef GST_DISABLE_GST_DEBUG
593 const gchar *debug_list;
595 if (g_getenv ("GST_DEBUG_NO_COLOR") != NULL)
596 gst_debug_set_colored (FALSE);
598 debug_list = g_getenv ("GST_DEBUG");
600 parse_debug_list (debug_list);
604 priv_gst_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
606 /* This is the earliest we can make stuff show up in the logs.
607 * So give some useful info about GStreamer here */
608 GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
609 GST_INFO ("Using library installed in %s", LIBDIR);
611 /* Print some basic system details if possible (OS/architecture) */
612 #ifdef HAVE_SYS_UTSNAME_H
614 struct utsname sys_details;
616 if (uname (&sys_details) == 0) {
617 GST_INFO ("%s %s %s %s %s", sys_details.sysname,
618 sys_details.nodename, sys_details.release, sys_details.version,
619 sys_details.machine);
628 gst_register_core_elements (GstPlugin * plugin)
630 /* register some standard builtin types */
631 if (!gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
633 !gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
636 g_assert_not_reached ();
641 #ifndef GST_DISABLE_REGISTRY
645 REGISTRY_SCAN_AND_UPDATE_FAILURE = 0,
646 REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED,
647 REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED
648 } GstRegistryScanAndUpdateResult;
651 * scan_and_update_registry:
652 * @default_registry: the #GstRegistry
653 * @registry_file: registry filename
654 * @write_changes: write registry if it has changed?
656 * Scans for registry changes and eventually updates the registry cache.
658 * Return: %REGISTRY_SCAN_AND_UPDATE_FAILURE if the registry could not scanned
659 * or updated, %REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED if the
660 * registry is clean and %REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED if
661 * it has been updated and the cache needs to be re-read.
663 static GstRegistryScanAndUpdateResult
664 scan_and_update_registry (GstRegistry * default_registry,
665 const gchar * registry_file, gboolean write_changes, GError ** error)
667 const gchar *plugin_path;
668 gboolean changed = FALSE;
671 GST_INFO ("Validating registry cache: %s", registry_file);
672 /* It sounds tempting to just compare the mtime of directories with the mtime
673 * of the registry cache, but it does not work. It would not catch updated
674 * plugins, which might bring more or less features.
677 /* scan paths specified via --gst-plugin-path */
678 GST_DEBUG ("scanning paths added via --gst-plugin-path");
679 for (l = plugin_paths; l != NULL; l = l->next) {
680 GST_INFO ("Scanning plugin path: \"%s\"", (gchar *) l->data);
681 changed |= gst_registry_scan_path (default_registry, (gchar *) l->data);
683 /* keep plugin_paths around in case a re-scan is forced later on */
685 /* GST_PLUGIN_PATH specifies a list of directories to scan for
686 * additional plugins. These take precedence over the system plugins */
687 plugin_path = g_getenv ("GST_PLUGIN_PATH");
692 GST_DEBUG ("GST_PLUGIN_PATH set to %s", plugin_path);
693 list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
694 for (i = 0; list[i]; i++) {
695 changed |= gst_registry_scan_path (default_registry, list[i]);
699 GST_DEBUG ("GST_PLUGIN_PATH not set");
702 /* GST_PLUGIN_SYSTEM_PATH specifies a list of plugins that are always
703 * loaded by default. If not set, this defaults to the system-installed
704 * path, and the plugins installed in the user's home directory */
705 plugin_path = g_getenv ("GST_PLUGIN_SYSTEM_PATH");
706 if (plugin_path == NULL) {
709 GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH not set");
711 /* plugins in the user's home directory take precedence over
712 * system-installed ones */
713 home_plugins = g_build_filename (g_get_home_dir (),
714 ".gstreamer-" GST_MAJORMINOR, "plugins", NULL);
715 GST_DEBUG ("scanning home plugins %s", home_plugins);
716 changed |= gst_registry_scan_path (default_registry, home_plugins);
717 g_free (home_plugins);
719 /* add the main (installed) library path */
720 GST_DEBUG ("scanning main plugins %s", PLUGINDIR);
721 changed |= gst_registry_scan_path (default_registry, PLUGINDIR);
726 GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH set to %s", plugin_path);
727 list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
728 for (i = 0; list[i]; i++) {
729 changed |= gst_registry_scan_path (default_registry, list[i]);
734 /* Remove cached plugins so stale info is cleared. */
735 changed |= _priv_gst_registry_remove_cache_plugins (default_registry);
738 GST_INFO ("Registry cache has not changed");
739 return REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED;
742 if (!write_changes) {
743 GST_INFO ("Registry cache changed, but writing is disabled. Not writing.");
744 return REGISTRY_SCAN_AND_UPDATE_FAILURE;
747 GST_INFO ("Registry cache changed. Writing new registry cache");
748 #ifdef USE_BINARY_REGISTRY
749 if (!gst_registry_binary_write_cache (default_registry, registry_file)) {
751 if (!gst_registry_xml_write_cache (default_registry, registry_file)) {
753 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
754 _("Error writing registry cache to %s: %s"),
755 registry_file, g_strerror (errno));
756 return REGISTRY_SCAN_AND_UPDATE_FAILURE;
759 GST_INFO ("Registry cache written successfully");
760 return REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED;
764 ensure_current_registry_nonforking (GstRegistry * default_registry,
765 const gchar * registry_file, GError ** error)
767 /* fork() not available */
768 GST_DEBUG ("Updating registry cache in-process");
769 scan_and_update_registry (default_registry, registry_file, TRUE, error);
773 /* when forking is not available this function always does nothing but return
776 ensure_current_registry_forking (GstRegistry * default_registry,
777 const gchar * registry_file, GError ** error)
784 /* We fork here, and let the child read and possibly rebuild the registry.
785 * After that, the parent will re-read the freshly generated registry. */
786 GST_DEBUG ("forking to update registry");
788 if (pipe (pfd) == -1) {
789 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
790 _("Error re-scanning registry %s: %s"),
791 ", could not create pipes. Error", g_strerror (errno));
797 GST_ERROR ("Failed to fork()");
798 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
799 _("Error re-scanning registry %s: %s"),
800 ", failed to fork. Error", g_strerror (errno));
807 /* this is the child. Close the read pipe */
808 (void) close (pfd[0]);
810 GST_DEBUG ("child reading registry cache");
812 scan_and_update_registry (default_registry, registry_file, TRUE, NULL);
814 /* need to use _exit, so that any exit handlers registered don't
815 * bring down the main program */
816 GST_DEBUG ("child exiting: %d", result_code);
818 /* make valgrind happy (yes, you can call it insane) */
819 g_free ((char *) registry_file);
821 /* write a result byte to the pipe */
823 ret = write (pfd[1], &result_code, sizeof (result_code));
824 } while (ret == -1 && errno == EINTR);
825 /* if ret == -1 now, we could not write to pipe, probably
826 * means parent has exited before us */
827 (void) close (pfd[1]);
833 /* parent. Close write pipe */
834 (void) close (pfd[1]);
836 /* Wait for result from the pipe */
837 GST_DEBUG ("Waiting for data from child");
839 ret = read (pfd[0], &result_code, sizeof (result_code));
840 } while (ret == -1 && errno == EINTR);
843 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
844 _("Error re-scanning registry %s: %s"),
845 ", read returned error", g_strerror (errno));
849 (void) close (pfd[0]);
851 /* Wait to ensure the child is reaped, but ignore the result */
852 GST_DEBUG ("parent waiting on child");
853 waitpid (pid, NULL, 0);
854 GST_DEBUG ("parent done waiting on child");
857 GST_ERROR ("child did not exit normally, terminated by signal");
858 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
859 _("Error re-scanning registry %s"), ", child terminated by signal");
863 if (result_code == REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED) {
864 GST_DEBUG ("Child succeeded. Parent reading registry cache");
865 _priv_gst_registry_remove_cache_plugins (default_registry);
866 #ifdef USE_BINARY_REGISTRY
867 gst_registry_binary_read_cache (default_registry, registry_file);
869 gst_registry_xml_read_cache (default_registry, registry_file);
871 } else if (result_code == REGISTRY_SCAN_AND_UPDATE_FAILURE) {
872 GST_DEBUG ("Child failed. Parent re-scanning registry, ignoring errors.");
873 scan_and_update_registry (default_registry, registry_file, FALSE, NULL);
876 #endif /* HAVE_FORK */
881 ensure_current_registry (GError ** error)
883 gchar *registry_file;
884 GstRegistry *default_registry;
889 default_registry = gst_registry_get_default ();
890 registry_file = g_strdup (g_getenv ("GST_REGISTRY"));
891 if (registry_file == NULL) {
892 #ifdef USE_BINARY_REGISTRY
893 registry_file = g_build_filename (g_get_home_dir (),
894 ".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".bin", NULL);
896 registry_file = g_build_filename (g_get_home_dir (),
897 ".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".xml", NULL);
901 GST_INFO ("reading registry cache: %s", registry_file);
902 #ifdef USE_BINARY_REGISTRY
903 gst_registry_binary_read_cache (default_registry, registry_file);
905 gst_registry_xml_read_cache (default_registry, registry_file);
908 do_update = !_gst_disable_registry_update;
910 const gchar *update_env;
912 if ((update_env = g_getenv ("GST_REGISTRY_UPDATE"))) {
913 /* do update for any value different from "no" */
914 do_update = (strcmp (update_env, "no") != 0);
919 /* first see if forking is enabled */
920 do_fork = _gst_enable_registry_fork;
922 const gchar *fork_env;
924 /* forking enabled, see if it is disabled with an env var */
925 if ((fork_env = g_getenv ("GST_REGISTRY_FORK"))) {
926 /* fork enabled for any value different from "no" */
927 do_fork = strcmp (fork_env, "no") != 0;
931 /* now check registry with or without forking */
933 GST_DEBUG ("forking for registry rebuild");
934 ret = ensure_current_registry_forking (default_registry, registry_file,
937 GST_DEBUG ("requested not to fork for registry rebuild");
938 ret = ensure_current_registry_nonforking (default_registry, registry_file,
943 g_free (registry_file);
944 GST_INFO ("registry reading and updating done, result = %d", ret);
948 #endif /* GST_DISABLE_REGISTRY */
952 * - initalization of threads if we use them
955 * - initializes gst_format
956 * - registers a bunch of types for gst_objects
958 * - we don't have cases yet where this fails, but in the future
959 * we might and then it's nice to be able to return that
962 init_post (GOptionContext * context, GOptionGroup * group, gpointer data,
967 #ifndef GST_DISABLE_TRACE
969 #endif /* GST_DISABLE_TRACE */
971 if (gst_initialized) {
972 GST_DEBUG ("already initialized");
976 llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
977 g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
979 _priv_gst_quarks_initialize ();
980 _gst_format_initialize ();
981 _gst_query_initialize ();
982 g_type_class_ref (gst_object_get_type ());
983 g_type_class_ref (gst_pad_get_type ());
984 g_type_class_ref (gst_element_factory_get_type ());
985 g_type_class_ref (gst_element_get_type ());
986 g_type_class_ref (gst_type_find_factory_get_type ());
987 g_type_class_ref (gst_bin_get_type ());
988 g_type_class_ref (gst_bus_get_type ());
989 g_type_class_ref (gst_task_get_type ());
990 g_type_class_ref (gst_clock_get_type ());
992 g_type_class_ref (gst_index_factory_get_type ());
993 gst_uri_handler_get_type ();
995 g_type_class_ref (gst_object_flags_get_type ());
996 g_type_class_ref (gst_bin_flags_get_type ());
997 g_type_class_ref (gst_buffer_flag_get_type ());
998 g_type_class_ref (gst_buffer_copy_flags_get_type ());
999 g_type_class_ref (gst_bus_flags_get_type ());
1000 g_type_class_ref (gst_bus_sync_reply_get_type ());
1001 g_type_class_ref (gst_caps_flags_get_type ());
1002 g_type_class_ref (gst_clock_return_get_type ());
1003 g_type_class_ref (gst_clock_entry_type_get_type ());
1004 g_type_class_ref (gst_clock_flags_get_type ());
1005 g_type_class_ref (gst_debug_graph_details_get_type ());
1006 g_type_class_ref (gst_state_get_type ());
1007 g_type_class_ref (gst_state_change_return_get_type ());
1008 g_type_class_ref (gst_state_change_get_type ());
1009 g_type_class_ref (gst_element_flags_get_type ());
1010 g_type_class_ref (gst_core_error_get_type ());
1011 g_type_class_ref (gst_library_error_get_type ());
1012 g_type_class_ref (gst_resource_error_get_type ());
1013 g_type_class_ref (gst_stream_error_get_type ());
1014 g_type_class_ref (gst_event_type_flags_get_type ());
1015 g_type_class_ref (gst_event_type_get_type ());
1016 g_type_class_ref (gst_seek_type_get_type ());
1017 g_type_class_ref (gst_seek_flags_get_type ());
1018 g_type_class_ref (gst_format_get_type ());
1019 g_type_class_ref (gst_index_certainty_get_type ());
1020 g_type_class_ref (gst_index_entry_type_get_type ());
1021 g_type_class_ref (gst_index_lookup_method_get_type ());
1022 g_type_class_ref (gst_assoc_flags_get_type ());
1023 g_type_class_ref (gst_index_resolver_method_get_type ());
1024 g_type_class_ref (gst_index_flags_get_type ());
1025 g_type_class_ref (gst_debug_level_get_type ());
1026 g_type_class_ref (gst_debug_color_flags_get_type ());
1027 g_type_class_ref (gst_iterator_result_get_type ());
1028 g_type_class_ref (gst_iterator_item_get_type ());
1029 g_type_class_ref (gst_message_type_get_type ());
1030 g_type_class_ref (gst_mini_object_flags_get_type ());
1031 g_type_class_ref (gst_pad_link_return_get_type ());
1032 g_type_class_ref (gst_flow_return_get_type ());
1033 g_type_class_ref (gst_activate_mode_get_type ());
1034 g_type_class_ref (gst_pad_direction_get_type ());
1035 g_type_class_ref (gst_pad_flags_get_type ());
1036 g_type_class_ref (gst_pad_presence_get_type ());
1037 g_type_class_ref (gst_pad_template_flags_get_type ());
1038 g_type_class_ref (gst_pipeline_flags_get_type ());
1039 g_type_class_ref (gst_plugin_error_get_type ());
1040 g_type_class_ref (gst_plugin_flags_get_type ());
1041 g_type_class_ref (gst_rank_get_type ());
1042 g_type_class_ref (gst_query_type_get_type ());
1043 g_type_class_ref (gst_buffering_mode_get_type ());
1044 g_type_class_ref (gst_tag_merge_mode_get_type ());
1045 g_type_class_ref (gst_tag_flag_get_type ());
1046 g_type_class_ref (gst_task_state_get_type ());
1047 g_type_class_ref (gst_alloc_trace_flags_get_type ());
1048 g_type_class_ref (gst_type_find_probability_get_type ());
1049 g_type_class_ref (gst_uri_type_get_type ());
1050 g_type_class_ref (gst_parse_error_get_type ());
1051 g_type_class_ref (gst_parse_flags_get_type ());
1053 gst_structure_get_type ();
1054 _gst_value_initialize ();
1055 g_type_class_ref (gst_param_spec_fraction_get_type ());
1056 gst_caps_get_type ();
1057 _gst_event_initialize ();
1058 _gst_buffer_initialize ();
1059 _gst_message_initialize ();
1060 _gst_tag_initialize ();
1062 _gst_plugin_initialize ();
1064 gst_g_error_get_type ();
1066 /* register core plugins */
1067 gst_plugin_register_static (GST_VERSION_MAJOR, GST_VERSION_MINOR,
1068 "staticelements", "core elements linked into the GStreamer library",
1069 gst_register_core_elements, VERSION, GST_LICENSE, PACKAGE,
1070 GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
1073 * Any errors happening below this point are non-fatal, we therefore mark
1074 * gstreamer as being initialized, since it is the case from a plugin point of
1077 * If anything fails, it will be put back to FALSE in gst_init_check().
1078 * This allows some special plugins that would call gst_init() to not cause a
1079 * looping effect (i.e. initializing GStreamer twice).
1081 gst_initialized = TRUE;
1083 #ifndef GST_DISABLE_REGISTRY
1084 if (!ensure_current_registry (error))
1086 #endif /* GST_DISABLE_REGISTRY */
1088 /* if we need to preload plugins, do so now */
1089 g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1090 /* keep preload_plugins around in case a re-scan is forced later on */
1092 #ifndef GST_DISABLE_TRACE
1094 if (_gst_trace_on) {
1095 gst_trace = gst_trace_new ("gst.trace", 1024);
1096 gst_trace_set_default (gst_trace);
1098 #endif /* GST_DISABLE_TRACE */
1103 #ifndef GST_DISABLE_GST_DEBUG
1105 select_all (GstPlugin * plugin, gpointer user_data)
1111 sort_by_category_name (gconstpointer a, gconstpointer b)
1113 return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
1114 gst_debug_category_get_name ((GstDebugCategory *) b));
1118 gst_debug_help (void)
1120 GSList *list, *walk;
1123 /* Need to ensure the registry is loaded to get debug categories */
1124 if (!init_post (NULL, NULL, NULL, NULL))
1127 list2 = gst_registry_plugin_filter (gst_registry_get_default (),
1128 select_all, FALSE, NULL);
1130 /* FIXME this is gross. why don't debug have categories PluginFeatures? */
1131 for (g = list2; g; g = g_list_next (g)) {
1132 GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
1134 gst_plugin_load (plugin);
1136 g_list_free (list2);
1138 list = gst_debug_get_all_categories ();
1139 walk = list = g_slist_sort (list, sort_by_category_name);
1142 g_print ("name level description\n");
1143 g_print ("---------------------+--------+--------------------------------\n");
1146 GstDebugCategory *cat = (GstDebugCategory *) walk->data;
1148 if (gst_debug_is_colored ()) {
1149 gchar *color = gst_debug_construct_term_color (cat->color);
1151 g_print ("%s%-20s\033[00m %1d %s %s%s\033[00m\n",
1153 gst_debug_category_get_name (cat),
1154 gst_debug_category_get_threshold (cat),
1155 gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1156 color, gst_debug_category_get_description (cat));
1159 g_print ("%-20s %1d %s %s\n", gst_debug_category_get_name (cat),
1160 gst_debug_category_get_threshold (cat),
1161 gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1162 gst_debug_category_get_description (cat));
1164 walk = g_slist_next (walk);
1166 g_slist_free (list);
1171 #ifndef GST_DISABLE_OPTION_PARSING
1173 parse_one_option (gint opt, const gchar * arg, GError ** err)
1177 g_print ("GStreamer Core Library version %s\n", PACKAGE_VERSION);
1179 case ARG_FATAL_WARNINGS:{
1180 GLogLevelFlags fatal_mask;
1182 fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
1183 fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
1184 g_log_set_always_fatal (fatal_mask);
1187 #ifndef GST_DISABLE_GST_DEBUG
1188 case ARG_DEBUG_LEVEL:{
1191 tmp = strtol (arg, NULL, 0);
1192 if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
1193 gst_debug_set_default_threshold (tmp);
1198 parse_debug_list (arg);
1200 case ARG_DEBUG_NO_COLOR:
1201 gst_debug_set_colored (FALSE);
1203 case ARG_DEBUG_DISABLE:
1204 gst_debug_set_active (FALSE);
1206 case ARG_DEBUG_HELP:
1210 case ARG_PLUGIN_SPEW:
1212 case ARG_PLUGIN_PATH:
1213 #ifndef GST_DISABLE_REGISTRY
1214 split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func, NULL);
1215 #endif /* GST_DISABLE_REGISTRY */
1217 case ARG_PLUGIN_LOAD:
1218 split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
1220 case ARG_SEGTRAP_DISABLE:
1221 _gst_disable_segtrap = TRUE;
1223 case ARG_REGISTRY_UPDATE_DISABLE:
1224 _gst_disable_registry_update = TRUE;
1226 case ARG_REGISTRY_FORK_DISABLE:
1227 _gst_enable_registry_fork = FALSE;
1230 g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
1231 _("Unknown option"));
1239 parse_goption_arg (const gchar * opt,
1240 const gchar * arg, gpointer data, GError ** err)
1248 "--gst-version", ARG_VERSION}, {
1249 "--gst-fatal-warnings", ARG_FATAL_WARNINGS},
1250 #ifndef GST_DISABLE_GST_DEBUG
1252 "--gst-debug-level", ARG_DEBUG_LEVEL}, {
1253 "--gst-debug", ARG_DEBUG}, {
1254 "--gst-debug-disable", ARG_DEBUG_DISABLE}, {
1255 "--gst-debug-no-color", ARG_DEBUG_NO_COLOR}, {
1256 "--gst-debug-help", ARG_DEBUG_HELP},
1259 "--gst-plugin-spew", ARG_PLUGIN_SPEW}, {
1260 "--gst-plugin-path", ARG_PLUGIN_PATH}, {
1261 "--gst-plugin-load", ARG_PLUGIN_LOAD}, {
1262 "--gst-disable-segtrap", ARG_SEGTRAP_DISABLE}, {
1263 "--gst-disable-registry-update", ARG_REGISTRY_UPDATE_DISABLE}, {
1264 "--gst-disable-registry-fork", ARG_REGISTRY_FORK_DISABLE}, {
1269 for (n = 0; options[n].opt; n++) {
1270 if (!strcmp (opt, options[n].opt)) {
1271 val = options[n].val;
1276 return parse_one_option (val, arg, err);
1280 extern GstRegistry *_gst_registry_default;
1285 * Clean up any resources created by GStreamer in gst_init().
1287 * It is normally not needed to call this function in a normal application
1288 * as the resources will automatically be freed when the program terminates.
1289 * This function is therefore mostly used by testsuites and other memory
1292 * After this call GStreamer (including this method) should not be used anymore.
1299 GST_INFO ("deinitializing GStreamer");
1301 if (gst_deinitialized) {
1302 GST_DEBUG ("already deinitialized");
1306 g_slist_foreach (preload_plugins, (GFunc) g_free, NULL);
1307 g_slist_free (preload_plugins);
1308 preload_plugins = NULL;
1310 #ifndef GST_DISABLE_REGISTRY
1311 g_list_foreach (plugin_paths, (GFunc) g_free, NULL);
1312 g_list_free (plugin_paths);
1313 plugin_paths = NULL;
1316 clock = gst_system_clock_obtain ();
1317 gst_object_unref (clock);
1318 gst_object_unref (clock);
1320 _priv_gst_registry_cleanup ();
1322 g_type_class_unref (g_type_class_peek (gst_object_get_type ()));
1323 g_type_class_unref (g_type_class_peek (gst_pad_get_type ()));
1324 g_type_class_unref (g_type_class_peek (gst_element_factory_get_type ()));
1325 g_type_class_unref (g_type_class_peek (gst_element_get_type ()));
1326 g_type_class_unref (g_type_class_peek (gst_type_find_factory_get_type ()));
1327 g_type_class_unref (g_type_class_peek (gst_bin_get_type ()));
1328 g_type_class_unref (g_type_class_peek (gst_bus_get_type ()));
1329 g_type_class_unref (g_type_class_peek (gst_task_get_type ()));
1330 g_type_class_unref (g_type_class_peek (gst_index_factory_get_type ()));
1331 g_type_class_unref (g_type_class_peek (gst_object_flags_get_type ()));
1332 g_type_class_unref (g_type_class_peek (gst_bin_flags_get_type ()));
1333 g_type_class_unref (g_type_class_peek (gst_buffer_flag_get_type ()));
1334 g_type_class_unref (g_type_class_peek (gst_buffer_copy_flags_get_type ()));
1335 g_type_class_unref (g_type_class_peek (gst_bus_flags_get_type ()));
1336 g_type_class_unref (g_type_class_peek (gst_bus_sync_reply_get_type ()));
1337 g_type_class_unref (g_type_class_peek (gst_caps_flags_get_type ()));
1338 g_type_class_unref (g_type_class_peek (gst_clock_return_get_type ()));
1339 g_type_class_unref (g_type_class_peek (gst_clock_entry_type_get_type ()));
1340 g_type_class_unref (g_type_class_peek (gst_clock_flags_get_type ()));
1341 g_type_class_unref (g_type_class_peek (gst_debug_graph_details_get_type ()));
1342 g_type_class_unref (g_type_class_peek (gst_state_get_type ()));
1343 g_type_class_unref (g_type_class_peek (gst_state_change_return_get_type ()));
1344 g_type_class_unref (g_type_class_peek (gst_state_change_get_type ()));
1345 g_type_class_unref (g_type_class_peek (gst_element_flags_get_type ()));
1346 g_type_class_unref (g_type_class_peek (gst_core_error_get_type ()));
1347 g_type_class_unref (g_type_class_peek (gst_library_error_get_type ()));
1348 g_type_class_unref (g_type_class_peek (gst_resource_error_get_type ()));
1349 g_type_class_unref (g_type_class_peek (gst_stream_error_get_type ()));
1350 g_type_class_unref (g_type_class_peek (gst_event_type_flags_get_type ()));
1351 g_type_class_unref (g_type_class_peek (gst_event_type_get_type ()));
1352 g_type_class_unref (g_type_class_peek (gst_seek_type_get_type ()));
1353 g_type_class_unref (g_type_class_peek (gst_seek_flags_get_type ()));
1354 g_type_class_unref (g_type_class_peek (gst_format_get_type ()));
1355 g_type_class_unref (g_type_class_peek (gst_index_certainty_get_type ()));
1356 g_type_class_unref (g_type_class_peek (gst_index_entry_type_get_type ()));
1357 g_type_class_unref (g_type_class_peek (gst_index_lookup_method_get_type ()));
1358 g_type_class_unref (g_type_class_peek (gst_assoc_flags_get_type ()));
1359 g_type_class_unref (g_type_class_peek (gst_index_resolver_method_get_type
1361 g_type_class_unref (g_type_class_peek (gst_index_flags_get_type ()));
1362 g_type_class_unref (g_type_class_peek (gst_debug_level_get_type ()));
1363 g_type_class_unref (g_type_class_peek (gst_debug_color_flags_get_type ()));
1364 g_type_class_unref (g_type_class_peek (gst_iterator_result_get_type ()));
1365 g_type_class_unref (g_type_class_peek (gst_iterator_item_get_type ()));
1366 g_type_class_unref (g_type_class_peek (gst_message_type_get_type ()));
1367 g_type_class_unref (g_type_class_peek (gst_mini_object_flags_get_type ()));
1368 g_type_class_unref (g_type_class_peek (gst_pad_link_return_get_type ()));
1369 g_type_class_unref (g_type_class_peek (gst_flow_return_get_type ()));
1370 g_type_class_unref (g_type_class_peek (gst_activate_mode_get_type ()));
1371 g_type_class_unref (g_type_class_peek (gst_pad_direction_get_type ()));
1372 g_type_class_unref (g_type_class_peek (gst_pad_flags_get_type ()));
1373 g_type_class_unref (g_type_class_peek (gst_pad_presence_get_type ()));
1374 g_type_class_unref (g_type_class_peek (gst_pad_template_flags_get_type ()));
1375 g_type_class_unref (g_type_class_peek (gst_pipeline_flags_get_type ()));
1376 g_type_class_unref (g_type_class_peek (gst_plugin_error_get_type ()));
1377 g_type_class_unref (g_type_class_peek (gst_plugin_flags_get_type ()));
1378 g_type_class_unref (g_type_class_peek (gst_rank_get_type ()));
1379 g_type_class_unref (g_type_class_peek (gst_query_type_get_type ()));
1380 g_type_class_unref (g_type_class_peek (gst_buffering_mode_get_type ()));
1381 g_type_class_unref (g_type_class_peek (gst_tag_merge_mode_get_type ()));
1382 g_type_class_unref (g_type_class_peek (gst_tag_flag_get_type ()));
1383 g_type_class_unref (g_type_class_peek (gst_task_state_get_type ()));
1384 g_type_class_unref (g_type_class_peek (gst_alloc_trace_flags_get_type ()));
1385 g_type_class_unref (g_type_class_peek (gst_type_find_probability_get_type
1387 g_type_class_unref (g_type_class_peek (gst_uri_type_get_type ()));
1388 g_type_class_unref (g_type_class_peek (gst_parse_error_get_type ()));
1389 g_type_class_unref (g_type_class_peek (gst_param_spec_fraction_get_type ()));
1391 gst_deinitialized = TRUE;
1392 GST_INFO ("deinitialized GStreamer");
1397 * @major: pointer to a guint to store the major version number
1398 * @minor: pointer to a guint to store the minor version number
1399 * @micro: pointer to a guint to store the micro version number
1400 * @nano: pointer to a guint to store the nano version number
1402 * Gets the version number of the GStreamer library.
1405 gst_version (guint * major, guint * minor, guint * micro, guint * nano)
1407 g_return_if_fail (major);
1408 g_return_if_fail (minor);
1409 g_return_if_fail (micro);
1410 g_return_if_fail (nano);
1412 *major = GST_VERSION_MAJOR;
1413 *minor = GST_VERSION_MINOR;
1414 *micro = GST_VERSION_MICRO;
1415 *nano = GST_VERSION_NANO;
1419 * gst_version_string:
1421 * This function returns a string that is useful for describing this version
1422 * of GStreamer to the outside world: user agent strings, logging, ...
1424 * Returns: a newly allocated string describing this version of GStreamer.
1428 gst_version_string ()
1430 guint major, minor, micro, nano;
1432 gst_version (&major, &minor, µ, &nano);
1434 return g_strdup_printf ("GStreamer %d.%d.%d", major, minor, micro);
1436 return g_strdup_printf ("GStreamer %d.%d.%d (CVS)", major, minor, micro);
1438 return g_strdup_printf ("GStreamer %d.%d.%d (prerelease)", major, minor,
1443 * gst_segtrap_is_enabled:
1445 * Some functions in the GStreamer core might install a custom SIGSEGV handler
1446 * to better catch and report errors to the application. Currently this feature
1447 * is enabled by default when loading plugins.
1449 * Applications might want to disable this behaviour with the
1450 * gst_segtrap_set_enabled() function. This is typically done if the application
1451 * wants to install its own handler without GStreamer interfering.
1453 * Returns: %TRUE if GStreamer is allowed to install a custom SIGSEGV handler.
1458 gst_segtrap_is_enabled (void)
1460 /* yeps, it's enabled when it's not disabled */
1461 return !_gst_disable_segtrap;
1465 * gst_segtrap_set_enabled:
1466 * @enabled: whether a custom SIGSEGV handler should be installed.
1468 * Applications might want to disable/enable the SIGSEGV handling of
1469 * the GStreamer core. See gst_segtrap_is_enabled() for more information.
1474 gst_segtrap_set_enabled (gboolean enabled)
1476 _gst_disable_segtrap = !enabled;
1480 * gst_registry_fork_is_enabled:
1482 * By default GStreamer will perform a fork() when scanning and rebuilding the
1485 * Applications might want to disable this behaviour with the
1486 * gst_registry_fork_set_enabled() function.
1488 * Returns: %TRUE if GStreamer will use fork() when rebuilding the registry. On
1489 * platforms without fork(), this function will always return %FALSE.
1494 gst_registry_fork_is_enabled (void)
1496 return _gst_enable_registry_fork;
1500 * gst_registry_fork_set_enabled:
1501 * @enabled: whether rebuilding the registry may fork
1503 * Applications might want to disable/enable the usage of fork() when rebuilding
1504 * the registry. See gst_registry_fork_is_enabled() for more information.
1506 * On platforms without fork(), this function will have no effect on the return
1507 * value of gst_registry_fork_is_enabled().
1512 gst_registry_fork_set_enabled (gboolean enabled)
1515 _gst_enable_registry_fork = enabled;
1516 #endif /* HAVE_FORK */
1521 * gst_update_registry:
1523 * Forces GStreamer to re-scan its plugin paths and update the default
1526 * Applications will almost never need to call this function, it is only
1527 * useful if the application knows new plugins have been installed (or old
1528 * ones removed) since the start of the application (or, to be precise, the
1529 * first call to gst_init()) and the application wants to make use of any
1530 * newly-installed plugins without restarting the application.
1532 * Applications should assume that the registry update is neither atomic nor
1533 * thread-safe and should therefore not have any dynamic pipelines running
1534 * (including the playbin and decodebin elements) and should also not create
1535 * any elements or access the GStreamer registry while the update is in
1538 * Note that this function may block for a significant amount of time.
1540 * Returns: %TRUE if the registry has been updated successfully (does not
1541 * imply that there were changes), otherwise %FALSE.
1546 gst_update_registry (void)
1548 gboolean res = FALSE;
1550 #ifndef GST_DISABLE_REGISTRY
1553 res = ensure_current_registry (&err);
1555 GST_WARNING ("registry update failed: %s", err->message);
1558 GST_LOG ("registry update succeeded");
1561 if (preload_plugins) {
1562 g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1565 GST_WARNING ("registry update failed: %s", "registry disabled");
1566 #endif /* GST_DISABLE_REGISTRY */