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 "gst_private.h"
107 #include "gstconfig.h"
110 #include <sys/types.h>
112 #include <sys/wait.h>
113 #endif /* HAVE_FORK */
114 #ifdef HAVE_SYS_UTSNAME_H
115 #include <sys/utsname.h>
121 #define WIN32_LEAN_AND_MEAN /* prevents from including too many things */
122 #include <windows.h> /* GetStdHandle, windows console */
125 #include "gst-i18n-lib.h"
126 #include <locale.h> /* for LC_ALL */
130 #define GST_CAT_DEFAULT GST_CAT_GST_INIT
132 #define MAX_PATH_SPLIT 16
133 #define GST_PLUGIN_SEPARATOR ","
135 static gboolean gst_initialized = FALSE;
136 static gboolean gst_deinitialized = FALSE;
139 static HMODULE gst_dll_handle = NULL;
142 #ifndef GST_DISABLE_REGISTRY
143 static GList *plugin_paths = NULL; /* for delayed processing in post_init */
146 #ifndef GST_DISABLE_GST_DEBUG
147 extern const gchar *priv_gst_dump_dot_dir;
151 #if defined(HAVE_FORK) && !defined(GST_HAVE_UNSAFE_FORK)
152 #define DEFAULT_FORK TRUE
154 #define DEFAULT_FORK FALSE
155 #endif /* HAVE_FORK */
157 /* set to TRUE when segfaults need to be left as is */
158 static gboolean _gst_disable_segtrap = FALSE;
160 /* control the behaviour of registry rebuild */
161 static gboolean _gst_enable_registry_fork = DEFAULT_FORK;
163 /*set to TRUE when registry needn't to be updated */
164 static gboolean _gst_disable_registry_update = FALSE;
166 static void load_plugin_func (gpointer data, gpointer user_data);
167 static gboolean init_pre (GOptionContext * context, GOptionGroup * group,
168 gpointer data, GError ** error);
169 static gboolean init_post (GOptionContext * context, GOptionGroup * group,
170 gpointer data, GError ** error);
171 #ifndef GST_DISABLE_OPTION_PARSING
172 static gboolean parse_goption_arg (const gchar * s_opt,
173 const gchar * arg, gpointer data, GError ** err);
176 static GSList *preload_plugins = NULL;
178 const gchar g_log_domain_gstreamer[] = "GStreamer";
181 debug_log_handler (const gchar * log_domain,
182 GLogLevelFlags log_level, const gchar * message, gpointer user_data)
184 g_log_default_handler (log_domain, log_level, message, user_data);
185 /* FIXME: do we still need this ? fatal errors these days are all
186 * other than core errors */
187 /* g_on_error_query (NULL); */
194 #ifndef GST_DISABLE_GST_DEBUG
205 ARG_REGISTRY_UPDATE_DISABLE,
206 ARG_REGISTRY_FORK_DISABLE
209 /* debug-spec ::= category-spec [, category-spec]*
210 * category-spec ::= category:val | val
219 #ifndef GST_DISABLE_GST_DEBUG
221 parse_debug_category (gchar * str, const gchar ** category)
238 parse_debug_level (gchar * str, gint * level)
246 if (str[0] != NUL && str[1] == NUL
247 && str[0] >= '0' && str[0] < '0' + GST_LEVEL_COUNT) {
248 *level = str[0] - '0';
256 parse_debug_list (const gchar * list)
261 g_return_if_fail (list != NULL);
263 split = g_strsplit (list, ",", 0);
265 for (walk = split; *walk; walk++) {
266 if (strchr (*walk, ':')) {
267 gchar **values = g_strsplit (*walk, ":", 2);
269 if (values[0] && values[1]) {
271 const gchar *category;
273 if (parse_debug_category (values[0], &category)
274 && parse_debug_level (values[1], &level))
275 gst_debug_set_threshold_for_name (category, level);
282 if (parse_debug_level (*walk, &level))
283 gst_debug_set_default_threshold (level);
293 DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
295 if (fdwReason == DLL_PROCESS_ATTACH)
296 gst_dll_handle = (HMODULE) hinstDLL;
303 * gst_init_get_option_group:
305 * Returns a #GOptionGroup with GStreamer's argument specifications. The
306 * group is set up to use standard GOption callbacks, so when using this
307 * group in combination with GOption parsing methods, all argument parsing
308 * and initialization is automated.
310 * This function is useful if you want to integrate GStreamer with other
311 * libraries that use GOption (see g_option_context_add_group() ).
313 * If you use this function, you should make sure you initialise the GLib
314 * threading system as one of the very first things in your program
315 * (see the example at the beginning of this section).
317 * Returns: a pointer to GStreamer's option group.
321 gst_init_get_option_group (void)
323 #ifndef GST_DISABLE_OPTION_PARSING
325 static const GOptionEntry gst_args[] = {
326 {"gst-version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
327 (gpointer) parse_goption_arg, N_("Print the GStreamer version"), NULL},
328 {"gst-fatal-warnings", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
329 (gpointer) parse_goption_arg, N_("Make all warnings fatal"), NULL},
330 #ifndef GST_DISABLE_GST_DEBUG
331 {"gst-debug-help", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
332 (gpointer) parse_goption_arg,
333 N_("Print available debug categories and exit"),
335 {"gst-debug-level", 0, 0, G_OPTION_ARG_CALLBACK,
336 (gpointer) parse_goption_arg,
337 N_("Default debug level from 1 (only error) to 5 (anything) or "
340 {"gst-debug", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) parse_goption_arg,
341 N_("Comma-separated list of category_name:level pairs to set "
342 "specific levels for the individual categories. Example: "
343 "GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
345 {"gst-debug-no-color", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
346 (gpointer) parse_goption_arg, N_("Disable colored debugging output"),
348 {"gst-debug-disable", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
349 (gpointer) parse_goption_arg, N_("Disable debugging"), NULL},
351 {"gst-plugin-spew", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
352 (gpointer) parse_goption_arg,
353 N_("Enable verbose plugin loading diagnostics"),
355 {"gst-plugin-path", 0, 0, G_OPTION_ARG_CALLBACK,
356 (gpointer) parse_goption_arg,
357 N_("Colon-separated paths containing plugins"), N_("PATHS")},
358 {"gst-plugin-load", 0, 0, G_OPTION_ARG_CALLBACK,
359 (gpointer) parse_goption_arg,
360 N_("Comma-separated list of plugins to preload in addition to the "
361 "list stored in environment variable GST_PLUGIN_PATH"),
363 {"gst-disable-segtrap", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
364 (gpointer) parse_goption_arg,
365 N_("Disable trapping of segmentation faults during plugin loading"),
367 {"gst-disable-registry-update", 0, G_OPTION_FLAG_NO_ARG,
368 G_OPTION_ARG_CALLBACK,
369 (gpointer) parse_goption_arg,
370 N_("Disable updating the registry"),
372 {"gst-disable-registry-fork", 0, G_OPTION_FLAG_NO_ARG,
373 G_OPTION_ARG_CALLBACK,
374 (gpointer) parse_goption_arg,
375 N_("Disable the use of fork() while scanning the registry"),
380 /* The GLib threading system must be initialised before calling any other
381 * GLib function according to the documentation; if the application hasn't
382 * called gst_init() yet or initialised the threading system otherwise, we
383 * better issue a warning here (since chances are high that the application
384 * has already called other GLib functions such as g_option_context_new() */
385 if (!g_thread_supported ()) {
386 g_warning ("The GStreamer function gst_init_get_option_group() was\n"
387 "\tcalled, but the GLib threading system has not been initialised\n"
388 "\tyet, something that must happen before any other GLib function\n"
389 "\tis called. The application needs to be fixed so that it calls\n"
390 "\t if (!g_thread_supported ()) g_thread_init(NULL);\n"
391 "\tas very first thing in its main() function. Please file a bug\n"
392 "\tagainst this application.");
393 g_thread_init (NULL);
396 group = g_option_group_new ("gst", _("GStreamer Options"),
397 _("Show GStreamer Options"), NULL, NULL);
398 g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,
399 (GOptionParseFunc) init_post);
401 g_option_group_add_entries (group, gst_args);
402 g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
412 * @argc: pointer to application's argc
413 * @argv: pointer to application's argv
414 * @err: pointer to a #GError to which a message will be posted on error
416 * Initializes the GStreamer library, setting up internal path lists,
417 * registering built-in elements, and loading standard plugins.
419 * This function will return %FALSE if GStreamer could not be initialized
420 * for some reason. If you want your program to fail fatally,
421 * use gst_init() instead.
423 * This function should be called before calling any other GLib functions. If
424 * this is not an option, your program must initialise the GLib thread system
425 * using g_thread_init() before any other GLib functions are called.
427 * Returns: %TRUE if GStreamer could be initialized.
430 gst_init_check (int *argc, char **argv[], GError ** err)
432 #ifndef GST_DISABLE_OPTION_PARSING
438 if (!g_thread_supported ())
439 g_thread_init (NULL);
441 if (gst_initialized) {
442 GST_DEBUG ("already initialized gst");
445 #ifndef GST_DISABLE_OPTION_PARSING
446 ctx = g_option_context_new ("- GStreamer initialization");
447 g_option_context_set_ignore_unknown_options (ctx, TRUE);
448 group = gst_init_get_option_group ();
449 g_option_context_add_group (ctx, group);
450 res = g_option_context_parse (ctx, argc, argv, err);
451 g_option_context_free (ctx);
453 init_pre (NULL, NULL, NULL, NULL);
454 init_post (NULL, NULL, NULL, NULL);
458 gst_initialized = res;
461 GST_INFO ("initialized GStreamer successfully");
463 GST_INFO ("failed to initialize GStreamer");
471 * @argc: pointer to application's argc
472 * @argv: pointer to application's argv
474 * Initializes the GStreamer library, setting up internal path lists,
475 * registering built-in elements, and loading standard plugins.
477 * This function should be called before calling any other GLib functions. If
478 * this is not an option, your program must initialise the GLib thread system
479 * using g_thread_init() before any other GLib functions are called.
482 * This function will terminate your program if it was unable to initialize
483 * GStreamer for some reason. If you want your program to fall back,
484 * use gst_init_check() instead.
487 * WARNING: This function does not work in the same way as corresponding
488 * functions in other glib-style libraries, such as gtk_init(). In
489 * particular, unknown command line options cause this function to
490 * abort program execution.
493 gst_init (int *argc, char **argv[])
497 if (!gst_init_check (argc, argv, &err)) {
498 g_print ("Could not initialize GStreamer: %s\n",
499 err ? err->message : "unknown error occurred");
507 #ifndef GST_DISABLE_REGISTRY
509 add_path_func (gpointer data, gpointer user_data)
511 GST_INFO ("Adding plugin path: \"%s\", will scan later", (gchar *) data);
512 plugin_paths = g_list_append (plugin_paths, g_strdup (data));
516 #ifndef GST_DISABLE_OPTION_PARSING
518 prepare_for_load_plugin_func (gpointer data, gpointer user_data)
520 preload_plugins = g_slist_prepend (preload_plugins, g_strdup (data));
525 load_plugin_func (gpointer data, gpointer user_data)
528 const gchar *filename;
531 filename = (const gchar *) data;
533 plugin = gst_plugin_load_file (filename, &err);
536 GST_INFO ("Loaded plugin: \"%s\"", filename);
538 gst_default_registry_add_plugin (plugin);
541 /* Report error to user, and free error */
542 GST_ERROR ("Failed to load plugin: %s", err->message);
545 GST_WARNING ("Failed to load plugin: \"%s\"", filename);
550 #ifndef GST_DISABLE_OPTION_PARSING
552 split_and_iterate (const gchar * stringlist, gchar * separator, GFunc iterator,
557 gchar *lastlist = g_strdup (stringlist);
560 strings = g_strsplit (lastlist, separator, MAX_PATH_SPLIT);
565 iterator (strings[j], user_data);
566 if (++j == MAX_PATH_SPLIT) {
567 lastlist = g_strdup (strings[j]);
572 g_strfreev (strings);
577 /* we have no fail cases yet, but maybe in the future */
579 init_pre (GOptionContext * context, GOptionGroup * group, gpointer data,
582 if (gst_initialized) {
583 GST_DEBUG ("already initialized");
587 /* GStreamer was built against a GLib >= 2.8 and is therefore not doing
588 * the refcount hack. Check that it isn't being run against an older GLib */
589 if (glib_major_version < 2 ||
590 (glib_major_version == 2 && glib_minor_version < 8)) {
591 g_warning ("GStreamer was compiled against GLib %d.%d.%d but is running"
592 " against %d.%d.%d. This will cause reference counting issues",
593 GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION,
594 glib_major_version, glib_minor_version, glib_micro_version);
599 /* we need threading to be enabled right here */
600 g_assert (g_thread_supported ());
604 setlocale (LC_ALL, "");
605 bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
606 bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
607 #endif /* ENABLE_NLS */
609 #ifndef GST_DISABLE_GST_DEBUG
611 const gchar *debug_list;
613 if (g_getenv ("GST_DEBUG_NO_COLOR") != NULL)
614 gst_debug_set_colored (FALSE);
616 debug_list = g_getenv ("GST_DEBUG");
618 parse_debug_list (debug_list);
622 priv_gst_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
624 /* This is the earliest we can make stuff show up in the logs.
625 * So give some useful info about GStreamer here */
626 GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
627 GST_INFO ("Using library installed in %s", LIBDIR);
629 /* Print some basic system details if possible (OS/architecture) */
630 #ifdef HAVE_SYS_UTSNAME_H
632 struct utsname sys_details;
634 if (uname (&sys_details) == 0) {
635 GST_INFO ("%s %s %s %s %s", sys_details.sysname,
636 sys_details.nodename, sys_details.release, sys_details.version,
637 sys_details.machine);
646 gst_register_core_elements (GstPlugin * plugin)
648 /* register some standard builtin types */
649 if (!gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
651 !gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
654 g_assert_not_reached ();
659 #ifndef GST_DISABLE_REGISTRY
663 REGISTRY_SCAN_AND_UPDATE_FAILURE = 0,
664 REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED,
665 REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED
666 } GstRegistryScanAndUpdateResult;
669 * scan_and_update_registry:
670 * @default_registry: the #GstRegistry
671 * @registry_file: registry filename
672 * @write_changes: write registry if it has changed?
674 * Scans for registry changes and eventually updates the registry cache.
676 * Return: %REGISTRY_SCAN_AND_UPDATE_FAILURE if the registry could not scanned
677 * or updated, %REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED if the
678 * registry is clean and %REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED if
679 * it has been updated and the cache needs to be re-read.
681 static GstRegistryScanAndUpdateResult
682 scan_and_update_registry (GstRegistry * default_registry,
683 const gchar * registry_file, gboolean write_changes, GError ** error)
685 const gchar *plugin_path;
686 gboolean changed = FALSE;
689 GST_INFO ("Validating registry cache: %s", registry_file);
690 /* It sounds tempting to just compare the mtime of directories with the mtime
691 * of the registry cache, but it does not work. It would not catch updated
692 * plugins, which might bring more or less features.
695 /* scan paths specified via --gst-plugin-path */
696 GST_DEBUG ("scanning paths added via --gst-plugin-path");
697 for (l = plugin_paths; l != NULL; l = l->next) {
698 GST_INFO ("Scanning plugin path: \"%s\"", (gchar *) l->data);
699 changed |= gst_registry_scan_path (default_registry, (gchar *) l->data);
701 /* keep plugin_paths around in case a re-scan is forced later on */
703 /* GST_PLUGIN_PATH specifies a list of directories to scan for
704 * additional plugins. These take precedence over the system plugins */
705 plugin_path = g_getenv ("GST_PLUGIN_PATH");
710 GST_DEBUG ("GST_PLUGIN_PATH set to %s", plugin_path);
711 list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
712 for (i = 0; list[i]; i++) {
713 changed |= gst_registry_scan_path (default_registry, list[i]);
717 GST_DEBUG ("GST_PLUGIN_PATH not set");
720 /* GST_PLUGIN_SYSTEM_PATH specifies a list of plugins that are always
721 * loaded by default. If not set, this defaults to the system-installed
722 * path, and the plugins installed in the user's home directory */
723 plugin_path = g_getenv ("GST_PLUGIN_SYSTEM_PATH");
724 if (plugin_path == NULL) {
727 GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH not set");
729 /* plugins in the user's home directory take precedence over
730 * system-installed ones */
731 home_plugins = g_build_filename (g_get_home_dir (),
732 ".gstreamer-" GST_MAJORMINOR, "plugins", NULL);
733 GST_DEBUG ("scanning home plugins %s", home_plugins);
734 changed |= gst_registry_scan_path (default_registry, home_plugins);
735 g_free (home_plugins);
737 /* add the main (installed) library path */
738 GST_DEBUG ("scanning main plugins %s", PLUGINDIR);
739 changed |= gst_registry_scan_path (default_registry, PLUGINDIR);
747 g_win32_get_package_installation_directory_of_module (gst_dll_handle);
749 dir = g_build_filename (base_dir, "lib", "gstreamer-0.10", NULL);
750 GST_DEBUG ("scanning DLL dir %s", dir);
752 changed |= gst_registry_scan_path (default_registry, dir);
762 GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH set to %s", plugin_path);
763 list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
764 for (i = 0; list[i]; i++) {
765 changed |= gst_registry_scan_path (default_registry, list[i]);
770 /* Remove cached plugins so stale info is cleared. */
771 changed |= _priv_gst_registry_remove_cache_plugins (default_registry);
774 GST_INFO ("Registry cache has not changed");
775 return REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED;
778 if (!write_changes) {
779 GST_INFO ("Registry cache changed, but writing is disabled. Not writing.");
780 return REGISTRY_SCAN_AND_UPDATE_FAILURE;
783 GST_INFO ("Registry cache changed. Writing new registry cache");
784 if (!gst_registry_binary_write_cache (default_registry, registry_file)) {
785 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
786 _("Error writing registry cache to %s: %s"),
787 registry_file, g_strerror (errno));
788 return REGISTRY_SCAN_AND_UPDATE_FAILURE;
791 GST_INFO ("Registry cache written successfully");
792 return REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED;
796 ensure_current_registry_nonforking (GstRegistry * default_registry,
797 const gchar * registry_file, GError ** error)
799 /* fork() not available */
800 GST_DEBUG ("Updating registry cache in-process");
801 scan_and_update_registry (default_registry, registry_file, TRUE, error);
805 /* when forking is not available this function always does nothing but return
808 ensure_current_registry_forking (GstRegistry * default_registry,
809 const gchar * registry_file, GError ** error)
816 /* We fork here, and let the child read and possibly rebuild the registry.
817 * After that, the parent will re-read the freshly generated registry. */
818 GST_DEBUG ("forking to update registry");
820 if (pipe (pfd) == -1) {
821 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
822 _("Error re-scanning registry %s: %s"),
823 ", could not create pipes. Error", g_strerror (errno));
829 GST_ERROR ("Failed to fork()");
830 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
831 _("Error re-scanning registry %s: %s"),
832 ", failed to fork. Error", g_strerror (errno));
839 /* this is the child. Close the read pipe */
840 (void) close (pfd[0]);
842 GST_DEBUG ("child reading registry cache");
844 scan_and_update_registry (default_registry, registry_file, TRUE, NULL);
846 /* need to use _exit, so that any exit handlers registered don't
847 * bring down the main program */
848 GST_DEBUG ("child exiting: %d", result_code);
850 /* make valgrind happy (yes, you can call it insane) */
851 g_free ((char *) registry_file);
853 /* write a result byte to the pipe */
855 ret = write (pfd[1], &result_code, sizeof (result_code));
856 } while (ret == -1 && errno == EINTR);
857 /* if ret == -1 now, we could not write to pipe, probably
858 * means parent has exited before us */
859 (void) close (pfd[1]);
865 /* parent. Close write pipe */
866 (void) close (pfd[1]);
868 /* Wait for result from the pipe */
869 GST_DEBUG ("Waiting for data from child");
871 ret = read (pfd[0], &result_code, sizeof (result_code));
872 } while (ret == -1 && errno == EINTR);
875 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
876 _("Error re-scanning registry %s: %s"),
877 ", read returned error", g_strerror (errno));
881 (void) close (pfd[0]);
883 /* Wait to ensure the child is reaped, but ignore the result */
884 GST_DEBUG ("parent waiting on child");
885 waitpid (pid, NULL, 0);
886 GST_DEBUG ("parent done waiting on child");
889 GST_ERROR ("child did not exit normally, terminated by signal");
890 g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
891 _("Error re-scanning registry %s"), ", child terminated by signal");
895 if (result_code == REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED) {
896 GST_DEBUG ("Child succeeded. Parent reading registry cache");
897 _priv_gst_registry_remove_cache_plugins (default_registry);
898 gst_registry_binary_read_cache (default_registry, registry_file);
899 } else if (result_code == REGISTRY_SCAN_AND_UPDATE_FAILURE) {
900 GST_DEBUG ("Child failed. Parent re-scanning registry, ignoring errors.");
901 scan_and_update_registry (default_registry, registry_file, FALSE, NULL);
904 #endif /* HAVE_FORK */
909 ensure_current_registry (GError ** error)
911 gchar *registry_file;
912 GstRegistry *default_registry;
918 default_registry = gst_registry_get_default ();
919 registry_file = g_strdup (g_getenv ("GST_REGISTRY"));
920 if (registry_file == NULL) {
921 registry_file = g_build_filename (g_get_home_dir (),
922 ".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".bin", NULL);
925 GST_INFO ("reading registry cache: %s", registry_file);
926 have_cache = gst_registry_binary_read_cache (default_registry, registry_file);
929 do_update = !_gst_disable_registry_update;
931 const gchar *update_env;
933 if ((update_env = g_getenv ("GST_REGISTRY_UPDATE"))) {
934 /* do update for any value different from "no" */
935 do_update = (strcmp (update_env, "no") != 0);
943 /* first see if forking is enabled */
944 do_fork = _gst_enable_registry_fork;
946 const gchar *fork_env;
948 /* forking enabled, see if it is disabled with an env var */
949 if ((fork_env = g_getenv ("GST_REGISTRY_FORK"))) {
950 /* fork enabled for any value different from "no" */
951 do_fork = strcmp (fork_env, "no") != 0;
955 /* now check registry with or without forking */
957 GST_DEBUG ("forking for registry rebuild");
958 ret = ensure_current_registry_forking (default_registry, registry_file,
961 GST_DEBUG ("requested not to fork for registry rebuild");
962 ret = ensure_current_registry_nonforking (default_registry, registry_file,
967 g_free (registry_file);
968 GST_INFO ("registry reading and updating done, result = %d", ret);
972 #endif /* GST_DISABLE_REGISTRY */
976 * - initalization of threads if we use them
979 * - initializes gst_format
980 * - registers a bunch of types for gst_objects
982 * - we don't have cases yet where this fails, but in the future
983 * we might and then it's nice to be able to return that
986 init_post (GOptionContext * context, GOptionGroup * group, gpointer data,
991 #ifndef GST_DISABLE_TRACE
993 #endif /* GST_DISABLE_TRACE */
995 if (gst_initialized) {
996 GST_DEBUG ("already initialized");
1000 llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
1001 g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
1003 _priv_gst_quarks_initialize ();
1004 _gst_format_initialize ();
1005 _gst_query_initialize ();
1006 g_type_class_ref (gst_object_get_type ());
1007 g_type_class_ref (gst_pad_get_type ());
1008 g_type_class_ref (gst_element_factory_get_type ());
1009 g_type_class_ref (gst_element_get_type ());
1010 g_type_class_ref (gst_type_find_factory_get_type ());
1011 g_type_class_ref (gst_bin_get_type ());
1012 g_type_class_ref (gst_bus_get_type ());
1013 g_type_class_ref (gst_task_get_type ());
1014 g_type_class_ref (gst_clock_get_type ());
1016 g_type_class_ref (gst_index_factory_get_type ());
1017 gst_uri_handler_get_type ();
1019 g_type_class_ref (gst_object_flags_get_type ());
1020 g_type_class_ref (gst_bin_flags_get_type ());
1021 g_type_class_ref (gst_buffer_flag_get_type ());
1022 g_type_class_ref (gst_buffer_copy_flags_get_type ());
1023 g_type_class_ref (gst_buffer_list_item_get_type ());
1024 g_type_class_ref (gst_bus_flags_get_type ());
1025 g_type_class_ref (gst_bus_sync_reply_get_type ());
1026 g_type_class_ref (gst_caps_flags_get_type ());
1027 g_type_class_ref (gst_clock_return_get_type ());
1028 g_type_class_ref (gst_clock_entry_type_get_type ());
1029 g_type_class_ref (gst_clock_flags_get_type ());
1030 g_type_class_ref (gst_clock_type_get_type ());
1031 g_type_class_ref (gst_debug_graph_details_get_type ());
1032 g_type_class_ref (gst_state_get_type ());
1033 g_type_class_ref (gst_state_change_return_get_type ());
1034 g_type_class_ref (gst_state_change_get_type ());
1035 g_type_class_ref (gst_element_flags_get_type ());
1036 g_type_class_ref (gst_core_error_get_type ());
1037 g_type_class_ref (gst_library_error_get_type ());
1038 g_type_class_ref (gst_resource_error_get_type ());
1039 g_type_class_ref (gst_stream_error_get_type ());
1040 g_type_class_ref (gst_event_type_flags_get_type ());
1041 g_type_class_ref (gst_event_type_get_type ());
1042 g_type_class_ref (gst_seek_type_get_type ());
1043 g_type_class_ref (gst_seek_flags_get_type ());
1044 g_type_class_ref (gst_format_get_type ());
1045 g_type_class_ref (gst_index_certainty_get_type ());
1046 g_type_class_ref (gst_index_entry_type_get_type ());
1047 g_type_class_ref (gst_index_lookup_method_get_type ());
1048 g_type_class_ref (gst_assoc_flags_get_type ());
1049 g_type_class_ref (gst_index_resolver_method_get_type ());
1050 g_type_class_ref (gst_index_flags_get_type ());
1051 g_type_class_ref (gst_debug_level_get_type ());
1052 g_type_class_ref (gst_debug_color_flags_get_type ());
1053 g_type_class_ref (gst_iterator_result_get_type ());
1054 g_type_class_ref (gst_iterator_item_get_type ());
1055 g_type_class_ref (gst_message_type_get_type ());
1056 g_type_class_ref (gst_mini_object_flags_get_type ());
1057 g_type_class_ref (gst_pad_link_return_get_type ());
1058 g_type_class_ref (gst_flow_return_get_type ());
1059 g_type_class_ref (gst_activate_mode_get_type ());
1060 g_type_class_ref (gst_pad_direction_get_type ());
1061 g_type_class_ref (gst_pad_flags_get_type ());
1062 g_type_class_ref (gst_pad_presence_get_type ());
1063 g_type_class_ref (gst_pad_template_flags_get_type ());
1064 g_type_class_ref (gst_pipeline_flags_get_type ());
1065 g_type_class_ref (gst_plugin_error_get_type ());
1066 g_type_class_ref (gst_plugin_flags_get_type ());
1067 g_type_class_ref (gst_plugin_dependency_flags_get_type ());
1068 g_type_class_ref (gst_rank_get_type ());
1069 g_type_class_ref (gst_query_type_get_type ());
1070 g_type_class_ref (gst_buffering_mode_get_type ());
1071 g_type_class_ref (gst_stream_status_type_get_type ());
1072 g_type_class_ref (gst_structure_change_type_get_type ());
1073 g_type_class_ref (gst_tag_merge_mode_get_type ());
1074 g_type_class_ref (gst_tag_flag_get_type ());
1075 g_type_class_ref (gst_task_pool_get_type ());
1076 g_type_class_ref (gst_task_state_get_type ());
1077 g_type_class_ref (gst_alloc_trace_flags_get_type ());
1078 g_type_class_ref (gst_type_find_probability_get_type ());
1079 g_type_class_ref (gst_uri_type_get_type ());
1080 g_type_class_ref (gst_parse_error_get_type ());
1081 g_type_class_ref (gst_parse_flags_get_type ());
1082 g_type_class_ref (gst_search_mode_get_type ());
1084 gst_structure_get_type ();
1085 _gst_value_initialize ();
1086 g_type_class_ref (gst_param_spec_fraction_get_type ());
1087 gst_caps_get_type ();
1088 _gst_event_initialize ();
1089 _gst_buffer_initialize ();
1090 _gst_buffer_list_initialize ();
1091 _gst_message_initialize ();
1092 _gst_tag_initialize ();
1094 _gst_plugin_initialize ();
1096 gst_g_error_get_type ();
1098 /* register core plugins */
1099 gst_plugin_register_static (GST_VERSION_MAJOR, GST_VERSION_MINOR,
1100 "staticelements", "core elements linked into the GStreamer library",
1101 gst_register_core_elements, VERSION, GST_LICENSE, PACKAGE,
1102 GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
1105 * Any errors happening below this point are non-fatal, we therefore mark
1106 * gstreamer as being initialized, since it is the case from a plugin point of
1109 * If anything fails, it will be put back to FALSE in gst_init_check().
1110 * This allows some special plugins that would call gst_init() to not cause a
1111 * looping effect (i.e. initializing GStreamer twice).
1113 gst_initialized = TRUE;
1115 #ifndef GST_DISABLE_REGISTRY
1116 if (!ensure_current_registry (error))
1118 #endif /* GST_DISABLE_REGISTRY */
1120 /* if we need to preload plugins, do so now */
1121 g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1122 /* keep preload_plugins around in case a re-scan is forced later on */
1124 #ifndef GST_DISABLE_TRACE
1126 if (_gst_trace_on) {
1127 gst_trace = gst_trace_new ("gst.trace", 1024);
1128 gst_trace_set_default (gst_trace);
1130 #endif /* GST_DISABLE_TRACE */
1135 #ifndef GST_DISABLE_GST_DEBUG
1137 select_all (GstPlugin * plugin, gpointer user_data)
1143 sort_by_category_name (gconstpointer a, gconstpointer b)
1145 return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
1146 gst_debug_category_get_name ((GstDebugCategory *) b));
1150 gst_debug_help (void)
1152 GSList *list, *walk;
1155 /* Need to ensure the registry is loaded to get debug categories */
1156 if (!init_post (NULL, NULL, NULL, NULL))
1159 list2 = gst_registry_plugin_filter (gst_registry_get_default (),
1160 select_all, FALSE, NULL);
1162 /* FIXME this is gross. why don't debug have categories PluginFeatures? */
1163 for (g = list2; g; g = g_list_next (g)) {
1164 GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
1166 gst_plugin_load (plugin);
1168 g_list_free (list2);
1170 list = gst_debug_get_all_categories ();
1171 walk = list = g_slist_sort (list, sort_by_category_name);
1174 g_print ("name level description\n");
1175 g_print ("---------------------+--------+--------------------------------\n");
1178 GstDebugCategory *cat = (GstDebugCategory *) walk->data;
1180 if (gst_debug_is_colored ()) {
1182 gint color = gst_debug_construct_win_color (cat->color);
1183 const gint clear = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
1185 SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
1186 g_print ("%-20s", gst_debug_category_get_name (cat));
1187 SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
1188 g_print (" %1d %s ", gst_debug_category_get_threshold (cat),
1189 gst_debug_level_get_name (gst_debug_category_get_threshold (cat)));
1190 SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
1191 g_print ("%s", gst_debug_category_get_description (cat));
1192 SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
1194 #else /* G_OS_WIN32 */
1195 gchar *color = gst_debug_construct_term_color (cat->color);
1197 g_print ("%s%-20s\033[00m %1d %s %s%s\033[00m\n",
1199 gst_debug_category_get_name (cat),
1200 gst_debug_category_get_threshold (cat),
1201 gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1202 color, gst_debug_category_get_description (cat));
1204 #endif /* G_OS_WIN32 */
1206 g_print ("%-20s %1d %s %s\n", gst_debug_category_get_name (cat),
1207 gst_debug_category_get_threshold (cat),
1208 gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1209 gst_debug_category_get_description (cat));
1211 walk = g_slist_next (walk);
1213 g_slist_free (list);
1218 #ifndef GST_DISABLE_OPTION_PARSING
1220 parse_one_option (gint opt, const gchar * arg, GError ** err)
1224 g_print ("GStreamer Core Library version %s\n", PACKAGE_VERSION);
1226 case ARG_FATAL_WARNINGS:{
1227 GLogLevelFlags fatal_mask;
1229 fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
1230 fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
1231 g_log_set_always_fatal (fatal_mask);
1234 #ifndef GST_DISABLE_GST_DEBUG
1235 case ARG_DEBUG_LEVEL:{
1238 tmp = strtol (arg, NULL, 0);
1239 if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
1240 gst_debug_set_default_threshold (tmp);
1245 parse_debug_list (arg);
1247 case ARG_DEBUG_NO_COLOR:
1248 gst_debug_set_colored (FALSE);
1250 case ARG_DEBUG_DISABLE:
1251 gst_debug_set_active (FALSE);
1253 case ARG_DEBUG_HELP:
1257 case ARG_PLUGIN_SPEW:
1259 case ARG_PLUGIN_PATH:
1260 #ifndef GST_DISABLE_REGISTRY
1261 split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func, NULL);
1262 #endif /* GST_DISABLE_REGISTRY */
1264 case ARG_PLUGIN_LOAD:
1265 split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
1267 case ARG_SEGTRAP_DISABLE:
1268 _gst_disable_segtrap = TRUE;
1270 case ARG_REGISTRY_UPDATE_DISABLE:
1271 _gst_disable_registry_update = TRUE;
1273 case ARG_REGISTRY_FORK_DISABLE:
1274 _gst_enable_registry_fork = FALSE;
1277 g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
1278 _("Unknown option"));
1286 parse_goption_arg (const gchar * opt,
1287 const gchar * arg, gpointer data, GError ** err)
1295 "--gst-version", ARG_VERSION}, {
1296 "--gst-fatal-warnings", ARG_FATAL_WARNINGS},
1297 #ifndef GST_DISABLE_GST_DEBUG
1299 "--gst-debug-level", ARG_DEBUG_LEVEL}, {
1300 "--gst-debug", ARG_DEBUG}, {
1301 "--gst-debug-disable", ARG_DEBUG_DISABLE}, {
1302 "--gst-debug-no-color", ARG_DEBUG_NO_COLOR}, {
1303 "--gst-debug-help", ARG_DEBUG_HELP},
1306 "--gst-plugin-spew", ARG_PLUGIN_SPEW}, {
1307 "--gst-plugin-path", ARG_PLUGIN_PATH}, {
1308 "--gst-plugin-load", ARG_PLUGIN_LOAD}, {
1309 "--gst-disable-segtrap", ARG_SEGTRAP_DISABLE}, {
1310 "--gst-disable-registry-update", ARG_REGISTRY_UPDATE_DISABLE}, {
1311 "--gst-disable-registry-fork", ARG_REGISTRY_FORK_DISABLE}, {
1316 for (n = 0; options[n].opt; n++) {
1317 if (!strcmp (opt, options[n].opt)) {
1318 val = options[n].val;
1323 return parse_one_option (val, arg, err);
1327 extern GstRegistry *_gst_registry_default;
1332 * Clean up any resources created by GStreamer in gst_init().
1334 * It is normally not needed to call this function in a normal application
1335 * as the resources will automatically be freed when the program terminates.
1336 * This function is therefore mostly used by testsuites and other memory
1339 * After this call GStreamer (including this method) should not be used anymore.
1346 GST_INFO ("deinitializing GStreamer");
1348 if (gst_deinitialized) {
1349 GST_DEBUG ("already deinitialized");
1353 g_slist_foreach (preload_plugins, (GFunc) g_free, NULL);
1354 g_slist_free (preload_plugins);
1355 preload_plugins = NULL;
1357 #ifndef GST_DISABLE_REGISTRY
1358 g_list_foreach (plugin_paths, (GFunc) g_free, NULL);
1359 g_list_free (plugin_paths);
1360 plugin_paths = NULL;
1363 clock = gst_system_clock_obtain ();
1364 gst_object_unref (clock);
1365 gst_object_unref (clock);
1367 _priv_gst_registry_cleanup ();
1369 g_type_class_unref (g_type_class_peek (gst_object_get_type ()));
1370 g_type_class_unref (g_type_class_peek (gst_pad_get_type ()));
1371 g_type_class_unref (g_type_class_peek (gst_element_factory_get_type ()));
1372 g_type_class_unref (g_type_class_peek (gst_element_get_type ()));
1373 g_type_class_unref (g_type_class_peek (gst_type_find_factory_get_type ()));
1374 g_type_class_unref (g_type_class_peek (gst_bin_get_type ()));
1375 g_type_class_unref (g_type_class_peek (gst_bus_get_type ()));
1376 g_type_class_unref (g_type_class_peek (gst_task_get_type ()));
1377 g_type_class_unref (g_type_class_peek (gst_index_factory_get_type ()));
1378 g_type_class_unref (g_type_class_peek (gst_object_flags_get_type ()));
1379 g_type_class_unref (g_type_class_peek (gst_bin_flags_get_type ()));
1380 g_type_class_unref (g_type_class_peek (gst_buffer_flag_get_type ()));
1381 g_type_class_unref (g_type_class_peek (gst_buffer_copy_flags_get_type ()));
1382 g_type_class_unref (g_type_class_peek (gst_bus_flags_get_type ()));
1383 g_type_class_unref (g_type_class_peek (gst_bus_sync_reply_get_type ()));
1384 g_type_class_unref (g_type_class_peek (gst_caps_flags_get_type ()));
1385 g_type_class_unref (g_type_class_peek (gst_clock_return_get_type ()));
1386 g_type_class_unref (g_type_class_peek (gst_clock_entry_type_get_type ()));
1387 g_type_class_unref (g_type_class_peek (gst_clock_flags_get_type ()));
1388 g_type_class_unref (g_type_class_peek (gst_debug_graph_details_get_type ()));
1389 g_type_class_unref (g_type_class_peek (gst_state_get_type ()));
1390 g_type_class_unref (g_type_class_peek (gst_state_change_return_get_type ()));
1391 g_type_class_unref (g_type_class_peek (gst_state_change_get_type ()));
1392 g_type_class_unref (g_type_class_peek (gst_element_flags_get_type ()));
1393 g_type_class_unref (g_type_class_peek (gst_core_error_get_type ()));
1394 g_type_class_unref (g_type_class_peek (gst_library_error_get_type ()));
1395 g_type_class_unref (g_type_class_peek (gst_resource_error_get_type ()));
1396 g_type_class_unref (g_type_class_peek (gst_stream_error_get_type ()));
1397 g_type_class_unref (g_type_class_peek (gst_event_type_flags_get_type ()));
1398 g_type_class_unref (g_type_class_peek (gst_event_type_get_type ()));
1399 g_type_class_unref (g_type_class_peek (gst_seek_type_get_type ()));
1400 g_type_class_unref (g_type_class_peek (gst_seek_flags_get_type ()));
1401 g_type_class_unref (g_type_class_peek (gst_format_get_type ()));
1402 g_type_class_unref (g_type_class_peek (gst_index_certainty_get_type ()));
1403 g_type_class_unref (g_type_class_peek (gst_index_entry_type_get_type ()));
1404 g_type_class_unref (g_type_class_peek (gst_index_lookup_method_get_type ()));
1405 g_type_class_unref (g_type_class_peek (gst_assoc_flags_get_type ()));
1406 g_type_class_unref (g_type_class_peek (gst_index_resolver_method_get_type
1408 g_type_class_unref (g_type_class_peek (gst_index_flags_get_type ()));
1409 g_type_class_unref (g_type_class_peek (gst_debug_level_get_type ()));
1410 g_type_class_unref (g_type_class_peek (gst_debug_color_flags_get_type ()));
1411 g_type_class_unref (g_type_class_peek (gst_iterator_result_get_type ()));
1412 g_type_class_unref (g_type_class_peek (gst_iterator_item_get_type ()));
1413 g_type_class_unref (g_type_class_peek (gst_message_type_get_type ()));
1414 g_type_class_unref (g_type_class_peek (gst_mini_object_flags_get_type ()));
1415 g_type_class_unref (g_type_class_peek (gst_pad_link_return_get_type ()));
1416 g_type_class_unref (g_type_class_peek (gst_flow_return_get_type ()));
1417 g_type_class_unref (g_type_class_peek (gst_activate_mode_get_type ()));
1418 g_type_class_unref (g_type_class_peek (gst_pad_direction_get_type ()));
1419 g_type_class_unref (g_type_class_peek (gst_pad_flags_get_type ()));
1420 g_type_class_unref (g_type_class_peek (gst_pad_presence_get_type ()));
1421 g_type_class_unref (g_type_class_peek (gst_pad_template_flags_get_type ()));
1422 g_type_class_unref (g_type_class_peek (gst_pipeline_flags_get_type ()));
1423 g_type_class_unref (g_type_class_peek (gst_plugin_error_get_type ()));
1424 g_type_class_unref (g_type_class_peek (gst_plugin_flags_get_type ()));
1425 g_type_class_unref (g_type_class_peek (gst_rank_get_type ()));
1426 g_type_class_unref (g_type_class_peek (gst_query_type_get_type ()));
1427 g_type_class_unref (g_type_class_peek (gst_buffering_mode_get_type ()));
1428 g_type_class_unref (g_type_class_peek (gst_tag_merge_mode_get_type ()));
1429 g_type_class_unref (g_type_class_peek (gst_tag_flag_get_type ()));
1430 g_type_class_unref (g_type_class_peek (gst_task_state_get_type ()));
1431 g_type_class_unref (g_type_class_peek (gst_alloc_trace_flags_get_type ()));
1432 g_type_class_unref (g_type_class_peek (gst_type_find_probability_get_type
1434 g_type_class_unref (g_type_class_peek (gst_uri_type_get_type ()));
1435 g_type_class_unref (g_type_class_peek (gst_parse_error_get_type ()));
1436 g_type_class_unref (g_type_class_peek (gst_param_spec_fraction_get_type ()));
1438 gst_deinitialized = TRUE;
1439 GST_INFO ("deinitialized GStreamer");
1444 * @major: pointer to a guint to store the major version number
1445 * @minor: pointer to a guint to store the minor version number
1446 * @micro: pointer to a guint to store the micro version number
1447 * @nano: pointer to a guint to store the nano version number
1449 * Gets the version number of the GStreamer library.
1452 gst_version (guint * major, guint * minor, guint * micro, guint * nano)
1454 g_return_if_fail (major);
1455 g_return_if_fail (minor);
1456 g_return_if_fail (micro);
1457 g_return_if_fail (nano);
1459 *major = GST_VERSION_MAJOR;
1460 *minor = GST_VERSION_MINOR;
1461 *micro = GST_VERSION_MICRO;
1462 *nano = GST_VERSION_NANO;
1466 * gst_version_string:
1468 * This function returns a string that is useful for describing this version
1469 * of GStreamer to the outside world: user agent strings, logging, ...
1471 * Returns: a newly allocated string describing this version of GStreamer.
1475 gst_version_string ()
1477 guint major, minor, micro, nano;
1479 gst_version (&major, &minor, µ, &nano);
1481 return g_strdup_printf ("GStreamer %d.%d.%d", major, minor, micro);
1483 return g_strdup_printf ("GStreamer %d.%d.%d (GIT)", major, minor, micro);
1485 return g_strdup_printf ("GStreamer %d.%d.%d (prerelease)", major, minor,
1490 * gst_segtrap_is_enabled:
1492 * Some functions in the GStreamer core might install a custom SIGSEGV handler
1493 * to better catch and report errors to the application. Currently this feature
1494 * is enabled by default when loading plugins.
1496 * Applications might want to disable this behaviour with the
1497 * gst_segtrap_set_enabled() function. This is typically done if the application
1498 * wants to install its own handler without GStreamer interfering.
1500 * Returns: %TRUE if GStreamer is allowed to install a custom SIGSEGV handler.
1505 gst_segtrap_is_enabled (void)
1507 /* yeps, it's enabled when it's not disabled */
1508 return !_gst_disable_segtrap;
1512 * gst_segtrap_set_enabled:
1513 * @enabled: whether a custom SIGSEGV handler should be installed.
1515 * Applications might want to disable/enable the SIGSEGV handling of
1516 * the GStreamer core. See gst_segtrap_is_enabled() for more information.
1521 gst_segtrap_set_enabled (gboolean enabled)
1523 _gst_disable_segtrap = !enabled;
1527 * gst_registry_fork_is_enabled:
1529 * By default GStreamer will perform a fork() when scanning and rebuilding the
1532 * Applications might want to disable this behaviour with the
1533 * gst_registry_fork_set_enabled() function.
1535 * Returns: %TRUE if GStreamer will use fork() when rebuilding the registry. On
1536 * platforms without fork(), this function will always return %FALSE.
1541 gst_registry_fork_is_enabled (void)
1543 return _gst_enable_registry_fork;
1547 * gst_registry_fork_set_enabled:
1548 * @enabled: whether rebuilding the registry may fork
1550 * Applications might want to disable/enable the usage of fork() when rebuilding
1551 * the registry. See gst_registry_fork_is_enabled() for more information.
1553 * On platforms without fork(), this function will have no effect on the return
1554 * value of gst_registry_fork_is_enabled().
1559 gst_registry_fork_set_enabled (gboolean enabled)
1562 _gst_enable_registry_fork = enabled;
1563 #endif /* HAVE_FORK */
1568 * gst_update_registry:
1570 * Forces GStreamer to re-scan its plugin paths and update the default
1573 * Applications will almost never need to call this function, it is only
1574 * useful if the application knows new plugins have been installed (or old
1575 * ones removed) since the start of the application (or, to be precise, the
1576 * first call to gst_init()) and the application wants to make use of any
1577 * newly-installed plugins without restarting the application.
1579 * Applications should assume that the registry update is neither atomic nor
1580 * thread-safe and should therefore not have any dynamic pipelines running
1581 * (including the playbin and decodebin elements) and should also not create
1582 * any elements or access the GStreamer registry while the update is in
1585 * Note that this function may block for a significant amount of time.
1587 * Returns: %TRUE if the registry has been updated successfully (does not
1588 * imply that there were changes), otherwise %FALSE.
1593 gst_update_registry (void)
1595 gboolean res = FALSE;
1597 #ifndef GST_DISABLE_REGISTRY
1600 res = ensure_current_registry (&err);
1602 GST_WARNING ("registry update failed: %s", err->message);
1605 GST_LOG ("registry update succeeded");
1608 if (preload_plugins) {
1609 g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1612 GST_WARNING ("registry update failed: %s", "registry disabled");
1613 #endif /* GST_DISABLE_REGISTRY */