Merge remote-tracking branch 'origin/master' into 0.11
[platform/upstream/gstreamer.git] / gst / gst.c
1 /* GStreamer
2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3  *                    2000 Wim Taymans <wtay@chello.be>
4  *
5  * gst.c: Initialization and non-pipeline operations
6  *
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.
11  *
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.
16  *
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.
21  */
22
23 /**
24  * SECTION:gst
25  * @short_description: Media library supporting arbitrary formats and filter
26  *                     graphs.
27  *
28  * GStreamer is a framework for constructing graphs of various filters
29  * (termed elements here) that will handle streaming media.  Any discreet
30  * (packetizable) media type is supported, with provisions for automatically
31  * determining source type.  Formatting/framing information is provided with
32  * a powerful negotiation framework.  Plugins are heavily used to provide for
33  * all elements, allowing one to construct plugins outside of the GST
34  * library, even released binary-only if license require (please don't).
35  * GStreamer covers a wide range of use cases including: playback, recording,
36  * editing, serving streams, voice over ip and video calls.
37  *
38  * The <application>GStreamer</application> library should be initialized with
39  * gst_init() before it can be used. You should pass pointers to the main argc
40  * and argv variables so that GStreamer can process its own command line
41  * options, as shown in the following example.
42  *
43  * <example>
44  * <title>Initializing the gstreamer library</title>
45  * <programlisting language="c">
46  * int
47  * main (int argc, char *argv[])
48  * {
49  *   // initialize the GStreamer library
50  *   gst_init (&amp;argc, &amp;argv);
51  *   ...
52  * }
53  * </programlisting>
54  * </example>
55  *
56  * It's allowed to pass two NULL pointers to gst_init() in case you don't want
57  * to pass the command line args to GStreamer.
58  *
59  * You can also use GOption to initialize your own parameters as shown in
60  * the next code fragment:
61  * <example>
62  * <title>Initializing own parameters when initializing gstreamer</title>
63  * <programlisting>
64  * static gboolean stats = FALSE;
65  * ...
66  * int
67  * main (int argc, char *argv[])
68  * {
69  *  GOptionEntry options[] = {
70  *   {"tags", 't', 0, G_OPTION_ARG_NONE, &amp;tags,
71  *       N_("Output tags (also known as metadata)"), NULL},
72  *   {NULL}
73  *  };
74  *  // must initialise the threading system before using any other GLib funtion
75  *  if (!g_thread_supported ())
76  *    g_thread_init (NULL);
77  *  ctx = g_option_context_new ("[ADDITIONAL ARGUMENTS]");
78  *  g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
79  *  g_option_context_add_group (ctx, gst_init_get_option_group ());
80  *  if (!g_option_context_parse (ctx, &amp;argc, &amp;argv, &amp;err)) {
81  *    g_print ("Error initializing: &percnt;s\n", GST_STR_NULL (err->message));
82  *    exit (1);
83  *  }
84  *  g_option_context_free (ctx);
85  * ...
86  * }
87  * </programlisting>
88  * </example>
89  *
90  * Use gst_version() to query the library version at runtime or use the
91  * GST_VERSION_* macros to find the version at compile time. Optionally
92  * gst_version_string() returns a printable string.
93  *
94  * The gst_deinit() call is used to clean up all internal resources used
95  * by <application>GStreamer</application>. It is mostly used in unit tests 
96  * to check for leaks.
97  *
98  * Last reviewed on 2006-08-11 (0.10.10)
99  */
100
101 #include "gst_private.h"
102 #include "gstconfig.h"
103 #include <stdlib.h>
104 #include <stdio.h>
105 #include <sys/types.h>
106 #ifdef HAVE_SYS_UTSNAME_H
107 #include <sys/utsname.h>
108 #endif
109 #ifdef HAVE_UNISTD_H
110 #include <unistd.h>
111 #endif
112 #ifdef G_OS_WIN32
113 #define WIN32_LEAN_AND_MEAN     /* prevents from including too many things */
114 #include <windows.h>            /* GetStdHandle, windows console */
115 #endif
116
117 #include "gst-i18n-lib.h"
118 #include <locale.h>             /* for LC_ALL */
119
120 #include "gst.h"
121
122 #define GST_CAT_DEFAULT GST_CAT_GST_INIT
123
124 #define MAX_PATH_SPLIT  16
125 #define GST_PLUGIN_SEPARATOR ","
126
127 static gboolean gst_initialized = FALSE;
128 static gboolean gst_deinitialized = FALSE;
129
130 #ifdef G_OS_WIN32
131 HMODULE _priv_gst_dll_handle = NULL;
132 #endif
133
134 #ifndef GST_DISABLE_REGISTRY
135 GList *_priv_gst_plugin_paths = NULL;   /* for delayed processing in post_init */
136
137 extern gboolean _priv_gst_disable_registry_update;
138 #endif
139
140 #ifndef GST_DISABLE_GST_DEBUG
141 extern const gchar *priv_gst_dump_dot_dir;
142 #endif
143
144 /* defaults */
145
146 /* set to TRUE when segfaults need to be left as is */
147 static gboolean _gst_disable_segtrap = FALSE;
148
149 static gboolean init_pre (GOptionContext * context, GOptionGroup * group,
150     gpointer data, GError ** error);
151 static gboolean init_post (GOptionContext * context, GOptionGroup * group,
152     gpointer data, GError ** error);
153 #ifndef GST_DISABLE_OPTION_PARSING
154 static gboolean parse_goption_arg (const gchar * s_opt,
155     const gchar * arg, gpointer data, GError ** err);
156 #endif
157
158 GSList *_priv_gst_preload_plugins = NULL;
159
160 const gchar g_log_domain_gstreamer[] = "GStreamer";
161
162 static void
163 debug_log_handler (const gchar * log_domain,
164     GLogLevelFlags log_level, const gchar * message, gpointer user_data)
165 {
166   g_log_default_handler (log_domain, log_level, message, user_data);
167   /* FIXME: do we still need this ? fatal errors these days are all
168    * other than core errors */
169   /* g_on_error_query (NULL); */
170 }
171
172 enum
173 {
174   ARG_VERSION = 1,
175   ARG_FATAL_WARNINGS,
176 #ifndef GST_DISABLE_GST_DEBUG
177   ARG_DEBUG_LEVEL,
178   ARG_DEBUG,
179   ARG_DEBUG_DISABLE,
180   ARG_DEBUG_NO_COLOR,
181   ARG_DEBUG_HELP,
182 #endif
183   ARG_PLUGIN_SPEW,
184   ARG_PLUGIN_PATH,
185   ARG_PLUGIN_LOAD,
186   ARG_SEGTRAP_DISABLE,
187   ARG_REGISTRY_UPDATE_DISABLE,
188   ARG_REGISTRY_FORK_DISABLE
189 };
190
191 /* debug-spec ::= category-spec [, category-spec]*
192  * category-spec ::= category:val | val
193  * category ::= [^:]+
194  * val ::= [0-5]
195  */
196
197 #ifndef NUL
198 #define NUL '\0'
199 #endif
200
201 #ifndef GST_DISABLE_GST_DEBUG
202 static gboolean
203 parse_debug_category (gchar * str, const gchar ** category)
204 {
205   if (!str)
206     return FALSE;
207
208   /* works in place */
209   g_strstrip (str);
210
211   if (str[0] != NUL) {
212     *category = str;
213     return TRUE;
214   }
215
216   return FALSE;
217 }
218
219 static gboolean
220 parse_debug_level (gchar * str, GstDebugLevel * level)
221 {
222   if (!str)
223     return FALSE;
224
225   /* works in place */
226   g_strstrip (str);
227
228   if (str[0] != NUL && str[1] == NUL
229       && str[0] >= '0' && str[0] < '0' + GST_LEVEL_COUNT) {
230     *level = (GstDebugLevel) (str[0] - '0');
231     return TRUE;
232   }
233
234   return FALSE;
235 }
236
237 static void
238 parse_debug_list (const gchar * list)
239 {
240   gchar **split;
241   gchar **walk;
242
243   g_assert (list);
244
245   split = g_strsplit (list, ",", 0);
246
247   for (walk = split; *walk; walk++) {
248     if (strchr (*walk, ':')) {
249       gchar **values = g_strsplit (*walk, ":", 2);
250
251       if (values[0] && values[1]) {
252         GstDebugLevel level;
253         const gchar *category;
254
255         if (parse_debug_category (values[0], &category)
256             && parse_debug_level (values[1], &level))
257           gst_debug_set_threshold_for_name (category, level);
258       }
259
260       g_strfreev (values);
261     } else {
262       GstDebugLevel level;
263
264       if (parse_debug_level (*walk, &level))
265         gst_debug_set_default_threshold (level);
266     }
267   }
268
269   g_strfreev (split);
270 }
271 #endif
272
273 #ifdef G_OS_WIN32
274 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);
275 BOOL WINAPI
276 DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
277 {
278   if (fdwReason == DLL_PROCESS_ATTACH)
279     _priv_gst_dll_handle = (HMODULE) hinstDLL;
280   return TRUE;
281 }
282
283 #endif
284
285 /**
286  * gst_init_get_option_group: (skip)
287  *
288  * Returns a #GOptionGroup with GStreamer's argument specifications. The
289  * group is set up to use standard GOption callbacks, so when using this
290  * group in combination with GOption parsing methods, all argument parsing
291  * and initialization is automated.
292  *
293  * This function is useful if you want to integrate GStreamer with other
294  * libraries that use GOption (see g_option_context_add_group() ).
295  *
296  * If you use this function, you should make sure you initialise the GLib
297  * threading system as one of the very first things in your program
298  * (see the example at the beginning of this section).
299  *
300  * Returns: (transfer full): a pointer to GStreamer's option group.
301  */
302
303 GOptionGroup *
304 gst_init_get_option_group (void)
305 {
306 #ifndef GST_DISABLE_OPTION_PARSING
307   GOptionGroup *group;
308   static const GOptionEntry gst_args[] = {
309     {"gst-version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
310         (gpointer) parse_goption_arg, N_("Print the GStreamer version"), NULL},
311     {"gst-fatal-warnings", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
312         (gpointer) parse_goption_arg, N_("Make all warnings fatal"), NULL},
313 #ifndef GST_DISABLE_GST_DEBUG
314     {"gst-debug-help", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
315           (gpointer) parse_goption_arg,
316           N_("Print available debug categories and exit"),
317         NULL},
318     {"gst-debug-level", 0, 0, G_OPTION_ARG_CALLBACK,
319           (gpointer) parse_goption_arg,
320           N_("Default debug level from 1 (only error) to 5 (anything) or "
321               "0 for no output"),
322         N_("LEVEL")},
323     {"gst-debug", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) parse_goption_arg,
324           N_("Comma-separated list of category_name:level pairs to set "
325               "specific levels for the individual categories. Example: "
326               "GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
327         N_("LIST")},
328     {"gst-debug-no-color", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
329           (gpointer) parse_goption_arg, N_("Disable colored debugging output"),
330         NULL},
331     {"gst-debug-disable", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
332         (gpointer) parse_goption_arg, N_("Disable debugging"), NULL},
333 #endif
334     {"gst-plugin-spew", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
335           (gpointer) parse_goption_arg,
336           N_("Enable verbose plugin loading diagnostics"),
337         NULL},
338     {"gst-plugin-path", 0, 0, G_OPTION_ARG_CALLBACK,
339           (gpointer) parse_goption_arg,
340         N_("Colon-separated paths containing plugins"), N_("PATHS")},
341     {"gst-plugin-load", 0, 0, G_OPTION_ARG_CALLBACK,
342           (gpointer) parse_goption_arg,
343           N_("Comma-separated list of plugins to preload in addition to the "
344               "list stored in environment variable GST_PLUGIN_PATH"),
345         N_("PLUGINS")},
346     {"gst-disable-segtrap", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
347           (gpointer) parse_goption_arg,
348           N_("Disable trapping of segmentation faults during plugin loading"),
349         NULL},
350     {"gst-disable-registry-update", 0, G_OPTION_FLAG_NO_ARG,
351           G_OPTION_ARG_CALLBACK,
352           (gpointer) parse_goption_arg,
353           N_("Disable updating the registry"),
354         NULL},
355     {"gst-disable-registry-fork", 0, G_OPTION_FLAG_NO_ARG,
356           G_OPTION_ARG_CALLBACK,
357           (gpointer) parse_goption_arg,
358           N_("Disable spawning a helper process while scanning the registry"),
359         NULL},
360     {NULL}
361   };
362
363   /* Since GLib 2.23.2 calling g_thread_init() 'late' is allowed and is
364    * automatically done as part of g_type_init() */
365   if (glib_check_version (2, 23, 3)) {
366     /* The GLib threading system must be initialised before calling any other
367      * GLib function according to the documentation; if the application hasn't
368      * called gst_init() yet or initialised the threading system otherwise, we
369      * better issue a warning here (since chances are high that the application
370      * has already called other GLib functions such as g_option_context_new() */
371     if (!g_thread_get_initialized ()) {
372       g_warning ("The GStreamer function gst_init_get_option_group() was\n"
373           "\tcalled, but the GLib threading system has not been initialised\n"
374           "\tyet, something that must happen before any other GLib function\n"
375           "\tis called. The application needs to be fixed so that it calls\n"
376           "\t   if (!g_thread_get_initialized ()) g_thread_init(NULL);\n"
377           "\tas very first thing in its main() function. Please file a bug\n"
378           "\tagainst this application.");
379       g_thread_init (NULL);
380     }
381   } else {
382     /* GLib >= 2.23.2 */
383   }
384
385   group = g_option_group_new ("gst", _("GStreamer Options"),
386       _("Show GStreamer Options"), NULL, NULL);
387   g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,
388       (GOptionParseFunc) init_post);
389
390   g_option_group_add_entries (group, gst_args);
391   g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
392
393   return group;
394 #else
395   return NULL;
396 #endif
397 }
398
399 /**
400  * gst_init_check:
401  * @argc: (inout) (allow-none): pointer to application's argc
402  * @argv: (inout) (array length=argc) (allow-none): pointer to application's argv
403  * @err: pointer to a #GError to which a message will be posted on error
404  *
405  * Initializes the GStreamer library, setting up internal path lists,
406  * registering built-in elements, and loading standard plugins.
407  *
408  * This function will return %FALSE if GStreamer could not be initialized
409  * for some reason.  If you want your program to fail fatally,
410  * use gst_init() instead.
411  *
412  * This function should be called before calling any other GLib functions. If
413  * this is not an option, your program must initialise the GLib thread system
414  * using g_thread_init() before any other GLib functions are called.
415  *
416  * Returns: %TRUE if GStreamer could be initialized.
417  */
418 gboolean
419 gst_init_check (int *argc, char **argv[], GError ** err)
420 {
421 #ifndef GST_DISABLE_OPTION_PARSING
422   GOptionGroup *group;
423   GOptionContext *ctx;
424 #endif
425   gboolean res;
426
427   if (!g_thread_get_initialized ())
428     g_thread_init (NULL);
429
430   if (gst_initialized) {
431     GST_DEBUG ("already initialized gst");
432     return TRUE;
433   }
434 #ifndef GST_DISABLE_OPTION_PARSING
435   ctx = g_option_context_new ("- GStreamer initialization");
436   g_option_context_set_ignore_unknown_options (ctx, TRUE);
437   group = gst_init_get_option_group ();
438   g_option_context_add_group (ctx, group);
439   res = g_option_context_parse (ctx, argc, argv, err);
440   g_option_context_free (ctx);
441 #else
442   init_pre (NULL, NULL, NULL, NULL);
443   init_post (NULL, NULL, NULL, NULL);
444   res = TRUE;
445 #endif
446
447   gst_initialized = res;
448
449   if (res) {
450     GST_INFO ("initialized GStreamer successfully");
451   } else {
452     GST_INFO ("failed to initialize GStreamer");
453   }
454
455   return res;
456 }
457
458 /**
459  * gst_init:
460  * @argc: (inout) (allow-none): pointer to application's argc
461  * @argv: (inout) (array length=argc) (allow-none): pointer to application's argv
462  *
463  * Initializes the GStreamer library, setting up internal path lists,
464  * registering built-in elements, and loading standard plugins.
465  *
466  * Unless the plugin registry is disabled at compile time, the registry will be
467  * loaded. By default this will also check if the registry cache needs to be
468  * updated and rescan all plugins if needed. See gst_update_registry() for
469  * details and section
470  * <link linkend="gst-running">Running GStreamer Applications</link>
471  * for how to disable automatic registry updates.
472  *
473  * This function should be called before calling any other GLib functions. If
474  * this is not an option, your program must initialise the GLib thread system
475  * using g_thread_init() before any other GLib functions are called.
476  *
477  * <note><para>
478  * This function will terminate your program if it was unable to initialize
479  * GStreamer for some reason.  If you want your program to fall back,
480  * use gst_init_check() instead.
481  * </para></note>
482  *
483  * WARNING: This function does not work in the same way as corresponding
484  * functions in other glib-style libraries, such as gtk_init().  In
485  * particular, unknown command line options cause this function to
486  * abort program execution.
487  */
488 void
489 gst_init (int *argc, char **argv[])
490 {
491   GError *err = NULL;
492
493   if (!gst_init_check (argc, argv, &err)) {
494     g_print ("Could not initialize GStreamer: %s\n",
495         err ? err->message : "unknown error occurred");
496     if (err) {
497       g_error_free (err);
498     }
499     exit (1);
500   }
501 }
502
503 /**
504  * gst_is_initialized:
505  *
506  * Use this function to check if GStreamer has been initialized with gst_init()
507  * or gst_init_check().
508  *
509  * Returns: TRUE if initialization has been done, FALSE otherwise.
510  *
511  * Since: 0.10.31
512  */
513 gboolean
514 gst_is_initialized (void)
515 {
516   return gst_initialized;
517 }
518
519 #ifndef GST_DISABLE_REGISTRY
520 static void
521 add_path_func (gpointer data, gpointer user_data)
522 {
523   GST_INFO ("Adding plugin path: \"%s\", will scan later", (gchar *) data);
524   _priv_gst_plugin_paths =
525       g_list_append (_priv_gst_plugin_paths, g_strdup (data));
526 }
527 #endif
528
529 #ifndef GST_DISABLE_OPTION_PARSING
530 static void
531 prepare_for_load_plugin_func (gpointer data, gpointer user_data)
532 {
533   _priv_gst_preload_plugins =
534       g_slist_prepend (_priv_gst_preload_plugins, g_strdup (data));
535 }
536 #endif
537
538 #ifndef GST_DISABLE_OPTION_PARSING
539 static void
540 split_and_iterate (const gchar * stringlist, const gchar * separator,
541     GFunc iterator, gpointer user_data)
542 {
543   gchar **strings;
544   gint j = 0;
545   gchar *lastlist = g_strdup (stringlist);
546
547   while (lastlist) {
548     strings = g_strsplit (lastlist, separator, MAX_PATH_SPLIT);
549     g_free (lastlist);
550     lastlist = NULL;
551
552     while (strings[j]) {
553       iterator (strings[j], user_data);
554       if (++j == MAX_PATH_SPLIT) {
555         lastlist = g_strdup (strings[j]);
556         j = 0;
557         break;
558       }
559     }
560     g_strfreev (strings);
561   }
562 }
563 #endif
564
565 /* we have no fail cases yet, but maybe in the future */
566 static gboolean
567 init_pre (GOptionContext * context, GOptionGroup * group, gpointer data,
568     GError ** error)
569 {
570   if (gst_initialized) {
571     GST_DEBUG ("already initialized");
572     return TRUE;
573   }
574
575   g_type_init ();
576
577   /* we need threading to be enabled right here */
578   g_assert (g_thread_get_initialized ());
579
580 #ifndef GST_DISABLE_GST_DEBUG
581   _priv_gst_debug_init ();
582 #endif
583
584 #ifdef ENABLE_NLS
585   setlocale (LC_ALL, "");
586   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
587   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
588 #endif /* ENABLE_NLS */
589
590 #ifndef GST_DISABLE_GST_DEBUG
591   {
592     const gchar *debug_list;
593
594     if (g_getenv ("GST_DEBUG_NO_COLOR") != NULL)
595       gst_debug_set_colored (FALSE);
596
597     debug_list = g_getenv ("GST_DEBUG");
598     if (debug_list) {
599       parse_debug_list (debug_list);
600     }
601   }
602
603   priv_gst_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
604 #endif
605   /* This is the earliest we can make stuff show up in the logs.
606    * So give some useful info about GStreamer here */
607   GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
608   GST_INFO ("Using library installed in %s", LIBDIR);
609
610   /* Print some basic system details if possible (OS/architecture) */
611 #ifdef HAVE_SYS_UTSNAME_H
612   {
613     struct utsname sys_details;
614
615     if (uname (&sys_details) == 0) {
616       GST_INFO ("%s %s %s %s %s", sys_details.sysname,
617           sys_details.nodename, sys_details.release, sys_details.version,
618           sys_details.machine);
619     }
620   }
621 #endif
622
623   return TRUE;
624 }
625
626 static gboolean
627 gst_register_core_elements (GstPlugin * plugin)
628 {
629   /* register some standard builtin types */
630   if (!gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
631           GST_TYPE_BIN) ||
632       !gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
633           GST_TYPE_PIPELINE)
634       )
635     g_assert_not_reached ();
636
637   return TRUE;
638 }
639
640 /*
641  * this bit handles:
642  * - initalization of threads if we use them
643  * - log handler
644  * - initial output
645  * - initializes gst_format
646  * - registers a bunch of types for gst_objects
647  *
648  * - we don't have cases yet where this fails, but in the future
649  *   we might and then it's nice to be able to return that
650  */
651 static gboolean
652 init_post (GOptionContext * context, GOptionGroup * group, gpointer data,
653     GError ** error)
654 {
655   GLogLevelFlags llf;
656
657 #ifndef GST_DISABLE_TRACE
658   GstTrace *gst_trace;
659 #endif /* GST_DISABLE_TRACE */
660
661   if (gst_initialized) {
662     GST_DEBUG ("already initialized");
663     return TRUE;
664   }
665
666   llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
667   g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
668
669   _priv_gst_quarks_initialize ();
670   _priv_gst_memory_initialize ();
671   _priv_gst_format_initialize ();
672   _priv_gst_query_initialize ();
673   _priv_gst_structure_initialize ();
674   _priv_gst_caps_initialize ();
675   _priv_gst_meta_initialize ();
676
677   g_type_class_ref (gst_object_get_type ());
678   g_type_class_ref (gst_pad_get_type ());
679   g_type_class_ref (gst_element_factory_get_type ());
680   g_type_class_ref (gst_element_get_type ());
681   g_type_class_ref (gst_type_find_factory_get_type ());
682   g_type_class_ref (gst_bin_get_type ());
683   g_type_class_ref (gst_bus_get_type ());
684   g_type_class_ref (gst_task_get_type ());
685   g_type_class_ref (gst_clock_get_type ());
686
687   g_type_class_ref (gst_index_factory_get_type ());
688   gst_uri_handler_get_type ();
689
690   g_type_class_ref (gst_object_flags_get_type ());
691   g_type_class_ref (gst_bin_flags_get_type ());
692   g_type_class_ref (gst_buffer_flags_get_type ());
693   g_type_class_ref (gst_buffer_copy_flags_get_type ());
694   g_type_class_ref (gst_bus_flags_get_type ());
695   g_type_class_ref (gst_bus_sync_reply_get_type ());
696   g_type_class_ref (gst_caps_flags_get_type ());
697   g_type_class_ref (gst_clock_return_get_type ());
698   g_type_class_ref (gst_clock_entry_type_get_type ());
699   g_type_class_ref (gst_clock_flags_get_type ());
700   g_type_class_ref (gst_clock_type_get_type ());
701   g_type_class_ref (gst_debug_graph_details_get_type ());
702   g_type_class_ref (gst_state_get_type ());
703   g_type_class_ref (gst_state_change_return_get_type ());
704   g_type_class_ref (gst_state_change_get_type ());
705   g_type_class_ref (gst_element_flags_get_type ());
706   g_type_class_ref (gst_core_error_get_type ());
707   g_type_class_ref (gst_library_error_get_type ());
708   g_type_class_ref (gst_resource_error_get_type ());
709   g_type_class_ref (gst_stream_error_get_type ());
710   g_type_class_ref (gst_event_type_flags_get_type ());
711   g_type_class_ref (gst_event_type_get_type ());
712   g_type_class_ref (gst_seek_type_get_type ());
713   g_type_class_ref (gst_seek_flags_get_type ());
714   g_type_class_ref (gst_qos_type_get_type ());
715   g_type_class_ref (gst_format_get_type ());
716   g_type_class_ref (gst_index_certainty_get_type ());
717   g_type_class_ref (gst_index_entry_type_get_type ());
718   g_type_class_ref (gst_index_lookup_method_get_type ());
719   g_type_class_ref (gst_assoc_flags_get_type ());
720   g_type_class_ref (gst_index_resolver_method_get_type ());
721   g_type_class_ref (gst_index_flags_get_type ());
722   g_type_class_ref (gst_debug_level_get_type ());
723   g_type_class_ref (gst_debug_color_flags_get_type ());
724   g_type_class_ref (gst_iterator_result_get_type ());
725   g_type_class_ref (gst_iterator_item_get_type ());
726   g_type_class_ref (gst_message_type_get_type ());
727   g_type_class_ref (gst_mini_object_flags_get_type ());
728   g_type_class_ref (gst_pad_link_return_get_type ());
729   g_type_class_ref (gst_pad_link_check_get_type ());
730   g_type_class_ref (gst_flow_return_get_type ());
731   g_type_class_ref (gst_pad_mode_get_type ());
732   g_type_class_ref (gst_pad_direction_get_type ());
733   g_type_class_ref (gst_pad_flags_get_type ());
734   g_type_class_ref (gst_pad_presence_get_type ());
735   g_type_class_ref (gst_pad_template_flags_get_type ());
736   g_type_class_ref (gst_pipeline_flags_get_type ());
737   g_type_class_ref (gst_plugin_error_get_type ());
738   g_type_class_ref (gst_plugin_flags_get_type ());
739   g_type_class_ref (gst_plugin_dependency_flags_get_type ());
740   g_type_class_ref (gst_rank_get_type ());
741   g_type_class_ref (gst_query_type_get_type ());
742   g_type_class_ref (gst_buffering_mode_get_type ());
743   g_type_class_ref (gst_stream_status_type_get_type ());
744   g_type_class_ref (gst_structure_change_type_get_type ());
745   g_type_class_ref (gst_tag_merge_mode_get_type ());
746   g_type_class_ref (gst_tag_flag_get_type ());
747   g_type_class_ref (gst_task_pool_get_type ());
748   g_type_class_ref (gst_task_state_get_type ());
749   g_type_class_ref (gst_alloc_trace_flags_get_type ());
750   g_type_class_ref (gst_type_find_probability_get_type ());
751   g_type_class_ref (gst_uri_error_get_type ());
752   g_type_class_ref (gst_uri_type_get_type ());
753   g_type_class_ref (gst_parse_error_get_type ());
754   g_type_class_ref (gst_parse_flags_get_type ());
755   g_type_class_ref (gst_search_mode_get_type ());
756   g_type_class_ref (gst_progress_type_get_type ());
757   g_type_class_ref (gst_buffer_pool_flags_get_type ());
758   g_type_class_ref (gst_memory_flags_get_type ());
759   g_type_class_ref (gst_map_flags_get_type ());
760   g_type_class_ref (gst_caps_intersect_mode_get_type ());
761   g_type_class_ref (gst_pad_probe_type_get_type ());
762   g_type_class_ref (gst_pad_probe_return_get_type ());
763   g_type_class_ref (gst_segment_flags_get_type ());
764   g_type_class_ref (gst_scheduling_flags_get_type ());
765
766   _priv_gst_event_initialize ();
767   _priv_gst_buffer_initialize ();
768   _priv_gst_message_initialize ();
769   _priv_gst_buffer_list_initialize ();
770   _priv_gst_value_initialize ();
771   g_type_class_ref (gst_param_spec_fraction_get_type ());
772   _priv_gst_tag_initialize ();
773   gst_parse_context_get_type ();
774
775   _priv_gst_plugin_initialize ();
776
777   gst_g_error_get_type ();
778
779   /* register core plugins */
780   gst_plugin_register_static (GST_VERSION_MAJOR, GST_VERSION_MINOR,
781       "staticelements", "core elements linked into the GStreamer library",
782       gst_register_core_elements, VERSION, GST_LICENSE, PACKAGE,
783       GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
784
785   /*
786    * Any errors happening below this point are non-fatal, we therefore mark
787    * gstreamer as being initialized, since it is the case from a plugin point of
788    * view.
789    *
790    * If anything fails, it will be put back to FALSE in gst_init_check().
791    * This allows some special plugins that would call gst_init() to not cause a
792    * looping effect (i.e. initializing GStreamer twice).
793    */
794   gst_initialized = TRUE;
795
796   if (!gst_update_registry ())
797     return FALSE;
798
799 #ifndef GST_DISABLE_TRACE
800   _gst_trace_on = 0;
801   if (_gst_trace_on) {
802     gst_trace = gst_trace_new ("gst.trace", 1024);
803     gst_trace_set_default (gst_trace);
804   }
805 #endif /* GST_DISABLE_TRACE */
806
807   GST_INFO ("GLib runtime version: %d.%d.%d", glib_major_version,
808       glib_minor_version, glib_micro_version);
809   GST_INFO ("GLib headers version: %d.%d.%d", GLIB_MAJOR_VERSION,
810       GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
811
812   return TRUE;
813 }
814
815 #ifndef GST_DISABLE_GST_DEBUG
816 static gboolean
817 select_all (GstPlugin * plugin, gpointer user_data)
818 {
819   return TRUE;
820 }
821
822 static gint
823 sort_by_category_name (gconstpointer a, gconstpointer b)
824 {
825   return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
826       gst_debug_category_get_name ((GstDebugCategory *) b));
827 }
828
829 static void
830 gst_debug_help (void)
831 {
832   GSList *list, *walk;
833   GList *list2, *g;
834
835   /* Need to ensure the registry is loaded to get debug categories */
836   if (!init_post (NULL, NULL, NULL, NULL))
837     exit (1);
838
839   list2 = gst_registry_plugin_filter (gst_registry_get_default (),
840       select_all, FALSE, NULL);
841
842   /* FIXME this is gross.  why don't debug have categories PluginFeatures? */
843   for (g = list2; g; g = g_list_next (g)) {
844     GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
845
846     gst_plugin_load (plugin);
847   }
848   g_list_free (list2);
849
850   list = gst_debug_get_all_categories ();
851   walk = list = g_slist_sort (list, sort_by_category_name);
852
853   g_print ("\n");
854   g_print ("name                  level    description\n");
855   g_print ("---------------------+--------+--------------------------------\n");
856
857   while (walk) {
858     GstDebugCategory *cat = (GstDebugCategory *) walk->data;
859
860     if (gst_debug_is_colored ()) {
861 #ifdef G_OS_WIN32
862       gint color = gst_debug_construct_win_color (cat->color);
863       const gint clear = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
864
865       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
866       g_print ("%-20s", gst_debug_category_get_name (cat));
867       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
868       g_print (" %1d %s ", gst_debug_category_get_threshold (cat),
869           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)));
870       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
871       g_print ("%s", gst_debug_category_get_description (cat));
872       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
873       g_print ("\n");
874 #else /* G_OS_WIN32 */
875       gchar *color = gst_debug_construct_term_color (cat->color);
876
877       g_print ("%s%-20s\033[00m  %1d %s  %s%s\033[00m\n",
878           color,
879           gst_debug_category_get_name (cat),
880           gst_debug_category_get_threshold (cat),
881           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
882           color, gst_debug_category_get_description (cat));
883       g_free (color);
884 #endif /* G_OS_WIN32 */
885     } else {
886       g_print ("%-20s  %1d %s  %s\n", gst_debug_category_get_name (cat),
887           gst_debug_category_get_threshold (cat),
888           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
889           gst_debug_category_get_description (cat));
890     }
891     walk = g_slist_next (walk);
892   }
893   g_slist_free (list);
894   g_print ("\n");
895 }
896 #endif
897
898 #ifndef GST_DISABLE_OPTION_PARSING
899 static gboolean
900 parse_one_option (gint opt, const gchar * arg, GError ** err)
901 {
902   switch (opt) {
903     case ARG_VERSION:
904       g_print ("GStreamer Core Library version %s\n", PACKAGE_VERSION);
905       exit (0);
906     case ARG_FATAL_WARNINGS:{
907       GLogLevelFlags fatal_mask;
908
909       fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
910       fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
911       g_log_set_always_fatal (fatal_mask);
912       break;
913     }
914 #ifndef GST_DISABLE_GST_DEBUG
915     case ARG_DEBUG_LEVEL:{
916       GstDebugLevel tmp = GST_LEVEL_NONE;
917
918       tmp = (GstDebugLevel) strtol (arg, NULL, 0);
919       if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
920         gst_debug_set_default_threshold (tmp);
921       }
922       break;
923     }
924     case ARG_DEBUG:
925       parse_debug_list (arg);
926       break;
927     case ARG_DEBUG_NO_COLOR:
928       gst_debug_set_colored (FALSE);
929       break;
930     case ARG_DEBUG_DISABLE:
931       gst_debug_set_active (FALSE);
932       break;
933     case ARG_DEBUG_HELP:
934       gst_debug_help ();
935       exit (0);
936 #endif
937     case ARG_PLUGIN_SPEW:
938       break;
939     case ARG_PLUGIN_PATH:
940 #ifndef GST_DISABLE_REGISTRY
941       split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func, NULL);
942 #endif /* GST_DISABLE_REGISTRY */
943       break;
944     case ARG_PLUGIN_LOAD:
945       split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
946       break;
947     case ARG_SEGTRAP_DISABLE:
948       _gst_disable_segtrap = TRUE;
949       break;
950     case ARG_REGISTRY_UPDATE_DISABLE:
951 #ifndef GST_DISABLE_REGISTRY
952       _priv_gst_disable_registry_update = TRUE;
953 #endif
954       break;
955     case ARG_REGISTRY_FORK_DISABLE:
956       gst_registry_fork_set_enabled (FALSE);
957       break;
958     default:
959       g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
960           _("Unknown option"));
961       return FALSE;
962   }
963
964   return TRUE;
965 }
966
967 static gboolean
968 parse_goption_arg (const gchar * opt,
969     const gchar * arg, gpointer data, GError ** err)
970 {
971   static const struct
972   {
973     const gchar *opt;
974     int val;
975   } options[] = {
976     {
977     "--gst-version", ARG_VERSION}, {
978     "--gst-fatal-warnings", ARG_FATAL_WARNINGS},
979 #ifndef GST_DISABLE_GST_DEBUG
980     {
981     "--gst-debug-level", ARG_DEBUG_LEVEL}, {
982     "--gst-debug", ARG_DEBUG}, {
983     "--gst-debug-disable", ARG_DEBUG_DISABLE}, {
984     "--gst-debug-no-color", ARG_DEBUG_NO_COLOR}, {
985     "--gst-debug-help", ARG_DEBUG_HELP},
986 #endif
987     {
988     "--gst-plugin-spew", ARG_PLUGIN_SPEW}, {
989     "--gst-plugin-path", ARG_PLUGIN_PATH}, {
990     "--gst-plugin-load", ARG_PLUGIN_LOAD}, {
991     "--gst-disable-segtrap", ARG_SEGTRAP_DISABLE}, {
992     "--gst-disable-registry-update", ARG_REGISTRY_UPDATE_DISABLE}, {
993     "--gst-disable-registry-fork", ARG_REGISTRY_FORK_DISABLE}, {
994     NULL}
995   };
996   gint val = 0, n;
997
998   for (n = 0; options[n].opt; n++) {
999     if (!strcmp (opt, options[n].opt)) {
1000       val = options[n].val;
1001       break;
1002     }
1003   }
1004
1005   return parse_one_option (val, arg, err);
1006 }
1007 #endif
1008
1009 /**
1010  * gst_deinit:
1011  *
1012  * Clean up any resources created by GStreamer in gst_init().
1013  *
1014  * It is normally not needed to call this function in a normal application
1015  * as the resources will automatically be freed when the program terminates.
1016  * This function is therefore mostly used by testsuites and other memory
1017  * profiling tools.
1018  *
1019  * After this call GStreamer (including this method) should not be used anymore. 
1020  */
1021 void
1022 gst_deinit (void)
1023 {
1024   GstClock *clock;
1025
1026   GST_INFO ("deinitializing GStreamer");
1027
1028   if (gst_deinitialized) {
1029     GST_DEBUG ("already deinitialized");
1030     return;
1031   }
1032
1033   g_slist_foreach (_priv_gst_preload_plugins, (GFunc) g_free, NULL);
1034   g_slist_free (_priv_gst_preload_plugins);
1035   _priv_gst_preload_plugins = NULL;
1036
1037 #ifndef GST_DISABLE_REGISTRY
1038   g_list_foreach (_priv_gst_plugin_paths, (GFunc) g_free, NULL);
1039   g_list_free (_priv_gst_plugin_paths);
1040   _priv_gst_plugin_paths = NULL;
1041 #endif
1042
1043   clock = gst_system_clock_obtain ();
1044   gst_object_unref (clock);
1045   gst_object_unref (clock);
1046
1047   _priv_gst_registry_cleanup ();
1048
1049   g_type_class_unref (g_type_class_peek (gst_object_get_type ()));
1050   g_type_class_unref (g_type_class_peek (gst_pad_get_type ()));
1051   g_type_class_unref (g_type_class_peek (gst_element_factory_get_type ()));
1052   g_type_class_unref (g_type_class_peek (gst_element_get_type ()));
1053   g_type_class_unref (g_type_class_peek (gst_type_find_factory_get_type ()));
1054   g_type_class_unref (g_type_class_peek (gst_bin_get_type ()));
1055   g_type_class_unref (g_type_class_peek (gst_bus_get_type ()));
1056   g_type_class_unref (g_type_class_peek (gst_task_get_type ()));
1057   g_type_class_unref (g_type_class_peek (gst_index_factory_get_type ()));
1058   g_type_class_unref (g_type_class_peek (gst_object_flags_get_type ()));
1059   g_type_class_unref (g_type_class_peek (gst_bin_flags_get_type ()));
1060   g_type_class_unref (g_type_class_peek (gst_buffer_flags_get_type ()));
1061   g_type_class_unref (g_type_class_peek (gst_buffer_copy_flags_get_type ()));
1062   g_type_class_unref (g_type_class_peek (gst_bus_flags_get_type ()));
1063   g_type_class_unref (g_type_class_peek (gst_bus_sync_reply_get_type ()));
1064   g_type_class_unref (g_type_class_peek (gst_caps_flags_get_type ()));
1065   g_type_class_unref (g_type_class_peek (gst_clock_type_get_type ()));
1066   g_type_class_unref (g_type_class_peek (gst_clock_return_get_type ()));
1067   g_type_class_unref (g_type_class_peek (gst_clock_entry_type_get_type ()));
1068   g_type_class_unref (g_type_class_peek (gst_clock_flags_get_type ()));
1069   g_type_class_unref (g_type_class_peek (gst_debug_graph_details_get_type ()));
1070   g_type_class_unref (g_type_class_peek (gst_state_get_type ()));
1071   g_type_class_unref (g_type_class_peek (gst_state_change_return_get_type ()));
1072   g_type_class_unref (g_type_class_peek (gst_state_change_get_type ()));
1073   g_type_class_unref (g_type_class_peek (gst_element_flags_get_type ()));
1074   g_type_class_unref (g_type_class_peek (gst_core_error_get_type ()));
1075   g_type_class_unref (g_type_class_peek (gst_library_error_get_type ()));
1076   g_type_class_unref (g_type_class_peek (gst_plugin_dependency_flags_get_type
1077           ()));
1078   g_type_class_unref (g_type_class_peek (gst_parse_flags_get_type ()));
1079   g_type_class_unref (g_type_class_peek (gst_resource_error_get_type ()));
1080   g_type_class_unref (g_type_class_peek (gst_search_mode_get_type ()));
1081   g_type_class_unref (g_type_class_peek (gst_stream_error_get_type ()));
1082   g_type_class_unref (g_type_class_peek (gst_stream_status_type_get_type ()));
1083   g_type_class_unref (g_type_class_peek (gst_structure_change_type_get_type
1084           ()));
1085   g_type_class_unref (g_type_class_peek (gst_event_type_flags_get_type ()));
1086   g_type_class_unref (g_type_class_peek (gst_event_type_get_type ()));
1087   g_type_class_unref (g_type_class_peek (gst_seek_type_get_type ()));
1088   g_type_class_unref (g_type_class_peek (gst_seek_flags_get_type ()));
1089   g_type_class_unref (g_type_class_peek (gst_qos_type_get_type ()));
1090   g_type_class_unref (g_type_class_peek (gst_format_get_type ()));
1091   g_type_class_unref (g_type_class_peek (gst_index_certainty_get_type ()));
1092   g_type_class_unref (g_type_class_peek (gst_index_entry_type_get_type ()));
1093   g_type_class_unref (g_type_class_peek (gst_index_lookup_method_get_type ()));
1094   g_type_class_unref (g_type_class_peek (gst_assoc_flags_get_type ()));
1095   g_type_class_unref (g_type_class_peek (gst_index_resolver_method_get_type
1096           ()));
1097   g_type_class_unref (g_type_class_peek (gst_index_flags_get_type ()));
1098   g_type_class_unref (g_type_class_peek (gst_debug_level_get_type ()));
1099   g_type_class_unref (g_type_class_peek (gst_debug_color_flags_get_type ()));
1100   g_type_class_unref (g_type_class_peek (gst_iterator_result_get_type ()));
1101   g_type_class_unref (g_type_class_peek (gst_iterator_item_get_type ()));
1102   g_type_class_unref (g_type_class_peek (gst_message_type_get_type ()));
1103   g_type_class_unref (g_type_class_peek (gst_mini_object_flags_get_type ()));
1104   g_type_class_unref (g_type_class_peek (gst_pad_link_return_get_type ()));
1105   g_type_class_unref (g_type_class_peek (gst_pad_link_check_get_type ()));
1106   g_type_class_unref (g_type_class_peek (gst_flow_return_get_type ()));
1107   g_type_class_unref (g_type_class_peek (gst_pad_mode_get_type ()));
1108   g_type_class_unref (g_type_class_peek (gst_pad_direction_get_type ()));
1109   g_type_class_unref (g_type_class_peek (gst_pad_flags_get_type ()));
1110   g_type_class_unref (g_type_class_peek (gst_pad_presence_get_type ()));
1111   g_type_class_unref (g_type_class_peek (gst_pad_template_flags_get_type ()));
1112   g_type_class_unref (g_type_class_peek (gst_pipeline_flags_get_type ()));
1113   g_type_class_unref (g_type_class_peek (gst_plugin_error_get_type ()));
1114   g_type_class_unref (g_type_class_peek (gst_plugin_flags_get_type ()));
1115   g_type_class_unref (g_type_class_peek (gst_rank_get_type ()));
1116   g_type_class_unref (g_type_class_peek (gst_query_type_get_type ()));
1117   g_type_class_unref (g_type_class_peek (gst_buffering_mode_get_type ()));
1118   g_type_class_unref (g_type_class_peek (gst_tag_merge_mode_get_type ()));
1119   g_type_class_unref (g_type_class_peek (gst_tag_flag_get_type ()));
1120   g_type_class_unref (g_type_class_peek (gst_task_state_get_type ()));
1121   g_type_class_unref (g_type_class_peek (gst_alloc_trace_flags_get_type ()));
1122   g_type_class_unref (g_type_class_peek (gst_type_find_probability_get_type
1123           ()));
1124   g_type_class_unref (g_type_class_peek (gst_uri_type_get_type ()));
1125   g_type_class_unref (g_type_class_peek (gst_uri_error_get_type ()));
1126   g_type_class_unref (g_type_class_peek (gst_parse_error_get_type ()));
1127   g_type_class_unref (g_type_class_peek (gst_param_spec_fraction_get_type ()));
1128   g_type_class_unref (g_type_class_peek (gst_progress_type_get_type ()));
1129   g_type_class_unref (g_type_class_peek (gst_buffer_pool_flags_get_type ()));
1130   g_type_class_unref (g_type_class_peek (gst_memory_flags_get_type ()));
1131   g_type_class_unref (g_type_class_peek (gst_map_flags_get_type ()));
1132   g_type_class_unref (g_type_class_peek (gst_caps_intersect_mode_get_type ()));
1133   g_type_class_unref (g_type_class_peek (gst_pad_probe_type_get_type ()));
1134   g_type_class_unref (g_type_class_peek (gst_pad_probe_return_get_type ()));
1135   g_type_class_unref (g_type_class_peek (gst_segment_flags_get_type ()));
1136   g_type_class_unref (g_type_class_peek (gst_scheduling_flags_get_type ()));
1137
1138   gst_deinitialized = TRUE;
1139   GST_INFO ("deinitialized GStreamer");
1140 }
1141
1142 /**
1143  * gst_version:
1144  * @major: (out): pointer to a guint to store the major version number
1145  * @minor: (out): pointer to a guint to store the minor version number
1146  * @micro: (out): pointer to a guint to store the micro version number
1147  * @nano:  (out): pointer to a guint to store the nano version number
1148  *
1149  * Gets the version number of the GStreamer library.
1150  */
1151 void
1152 gst_version (guint * major, guint * minor, guint * micro, guint * nano)
1153 {
1154   g_return_if_fail (major);
1155   g_return_if_fail (minor);
1156   g_return_if_fail (micro);
1157   g_return_if_fail (nano);
1158
1159   *major = GST_VERSION_MAJOR;
1160   *minor = GST_VERSION_MINOR;
1161   *micro = GST_VERSION_MICRO;
1162   *nano = GST_VERSION_NANO;
1163 }
1164
1165 /**
1166  * gst_version_string:
1167  *
1168  * This function returns a string that is useful for describing this version
1169  * of GStreamer to the outside world: user agent strings, logging, ...
1170  *
1171  * Returns: (transfer full): a newly allocated string describing this version
1172  *     of GStreamer.
1173  */
1174
1175 gchar *
1176 gst_version_string (void)
1177 {
1178   guint major, minor, micro, nano;
1179
1180   gst_version (&major, &minor, &micro, &nano);
1181   if (nano == 0)
1182     return g_strdup_printf ("GStreamer %d.%d.%d", major, minor, micro);
1183   else if (nano == 1)
1184     return g_strdup_printf ("GStreamer %d.%d.%d (GIT)", major, minor, micro);
1185   else
1186     return g_strdup_printf ("GStreamer %d.%d.%d (prerelease)", major, minor,
1187         micro);
1188 }
1189
1190 /**
1191  * gst_segtrap_is_enabled:
1192  *
1193  * Some functions in the GStreamer core might install a custom SIGSEGV handler
1194  * to better catch and report errors to the application. Currently this feature
1195  * is enabled by default when loading plugins.
1196  *
1197  * Applications might want to disable this behaviour with the
1198  * gst_segtrap_set_enabled() function. This is typically done if the application
1199  * wants to install its own handler without GStreamer interfering.
1200  *
1201  * Returns: %TRUE if GStreamer is allowed to install a custom SIGSEGV handler.
1202  *
1203  * Since: 0.10.10
1204  */
1205 gboolean
1206 gst_segtrap_is_enabled (void)
1207 {
1208   /* yeps, it's enabled when it's not disabled */
1209   return !_gst_disable_segtrap;
1210 }
1211
1212 /**
1213  * gst_segtrap_set_enabled:
1214  * @enabled: whether a custom SIGSEGV handler should be installed.
1215  *
1216  * Applications might want to disable/enable the SIGSEGV handling of
1217  * the GStreamer core. See gst_segtrap_is_enabled() for more information.
1218  *
1219  * Since: 0.10.10
1220  */
1221 void
1222 gst_segtrap_set_enabled (gboolean enabled)
1223 {
1224   _gst_disable_segtrap = !enabled;
1225 }