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.31.0 threading is always enabled and g_thread_init()
 364  * is not needed any longer and deprecated */
 365 #if !GLIB_CHECK_VERSION (2, 31, 0)
 366   /* Since GLib 2.23.2 calling g_thread_init() 'late' is allowed and is
 367    * automatically done as part of g_type_init() */
 368   if (glib_check_version (2, 23, 3)) {
 369     /* The GLib threading system must be initialised before calling any other
 370      * GLib function according to the documentation; if the application hasn't
 371      * called gst_init() yet or initialised the threading system otherwise, we
 372      * better issue a warning here (since chances are high that the application
 373      * has already called other GLib functions such as g_option_context_new() */
 374     if (!g_thread_get_initialized ()) {
 375       g_warning ("The GStreamer function gst_init_get_option_group() was\n"
 376           "\tcalled, but the GLib threading system has not been initialised\n"
 377           "\tyet, something that must happen before any other GLib function\n"
 378           "\tis called. The application needs to be fixed so that it calls\n"
 379           "\t   if (!g_thread_get_initialized ()) g_thread_init(NULL);\n"
 380           "\tas very first thing in its main() function. Please file a bug\n"
 381           "\tagainst this application.");
 382       g_thread_init (NULL);
 383     }
 384   } else {
 385     /* GLib >= 2.23.2 */
 386   }
 387 #endif
 388
 389   group = g_option_group_new ("gst", _("GStreamer Options"),
 390       _("Show GStreamer Options"), NULL, NULL);
 391   g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,
 392       (GOptionParseFunc) init_post);
 393
 394   g_option_group_add_entries (group, gst_args);
 395   g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
 396
 397   return group;
 398 #else
 399   return NULL;
 400 #endif
 401 }
 402
 403 /**
 404  * gst_init_check:
 405  * @argc: (inout) (allow-none): pointer to application's argc
 406  * @argv: (inout) (array length=argc) (allow-none): pointer to application's argv
 407  * @err: pointer to a #GError to which a message will be posted on error
 408  *
 409  * Initializes the GStreamer library, setting up internal path lists,
 410  * registering built-in elements, and loading standard plugins.
 411  *
 412  * This function will return %FALSE if GStreamer could not be initialized
 413  * for some reason.  If you want your program to fail fatally,
 414  * use gst_init() instead.
 415  *
 416  * This function should be called before calling any other GLib functions. If
 417  * this is not an option, your program must initialise the GLib thread system
 418  * using g_thread_init() before any other GLib functions are called.
 419  *
 420  * Returns: %TRUE if GStreamer could be initialized.
 421  */
 422 gboolean
 423 gst_init_check (int *argc, char **argv[], GError ** err)
 424 {
 425 #ifndef GST_DISABLE_OPTION_PARSING
 426   GOptionGroup *group;
 427   GOptionContext *ctx;
 428 #endif
 429   gboolean res;
 430
 431 #if !GLIB_CHECK_VERSION (2, 31, 0)
 432   if (!g_thread_get_initialized ())
 433     g_thread_init (NULL);
 434 #endif
 435
 436   if (gst_initialized) {
 437     GST_DEBUG ("already initialized gst");
 438     return TRUE;
 439   }
 440 #ifndef GST_DISABLE_OPTION_PARSING
 441   ctx = g_option_context_new ("- GStreamer initialization");
 442   g_option_context_set_ignore_unknown_options (ctx, TRUE);
 443   group = gst_init_get_option_group ();
 444   g_option_context_add_group (ctx, group);
 445   res = g_option_context_parse (ctx, argc, argv, err);
 446   g_option_context_free (ctx);
 447 #else
 448   init_pre (NULL, NULL, NULL, NULL);
 449   init_post (NULL, NULL, NULL, NULL);
 450   res = TRUE;
 451 #endif
 452
 453   gst_initialized = res;
 454
 455   if (res) {
 456     GST_INFO ("initialized GStreamer successfully");
 457   } else {
 458     GST_INFO ("failed to initialize GStreamer");
 459   }
 460
 461   return res;
 462 }
 463
 464 /**
 465  * gst_init:
 466  * @argc: (inout) (allow-none): pointer to application's argc
 467  * @argv: (inout) (array length=argc) (allow-none): pointer to application's argv
 468  *
 469  * Initializes the GStreamer library, setting up internal path lists,
 470  * registering built-in elements, and loading standard plugins.
 471  *
 472  * Unless the plugin registry is disabled at compile time, the registry will be
 473  * loaded. By default this will also check if the registry cache needs to be
 474  * updated and rescan all plugins if needed. See gst_update_registry() for
 475  * details and section
 476  * <link linkend="gst-running">Running GStreamer Applications</link>
 477  * for how to disable automatic registry updates.
 478  *
 479  * This function should be called before calling any other GLib functions. If
 480  * this is not an option, your program must initialise the GLib thread system
 481  * using g_thread_init() before any other GLib functions are called.
 482  *
 483  * <note><para>
 484  * This function will terminate your program if it was unable to initialize
 485  * GStreamer for some reason.  If you want your program to fall back,
 486  * use gst_init_check() instead.
 487  * </para></note>
 488  *
 489  * WARNING: This function does not work in the same way as corresponding
 490  * functions in other glib-style libraries, such as gtk_init().  In
 491  * particular, unknown command line options cause this function to
 492  * abort program execution.
 493  */
 494 void
 495 gst_init (int *argc, char **argv[])
 496 {
 497   GError *err = NULL;
 498
 499   if (!gst_init_check (argc, argv, &err)) {
 500     g_print ("Could not initialize GStreamer: %s\n",
 501         err ? err->message : "unknown error occurred");
 502     if (err) {
 503       g_error_free (err);
 504     }
 505     exit (1);
 506   }
 507 }
 508
 509 /**
 510  * gst_is_initialized:
 511  *
 512  * Use this function to check if GStreamer has been initialized with gst_init()
 513  * or gst_init_check().
 514  *
 515  * Returns: TRUE if initialization has been done, FALSE otherwise.
 516  *
 517  * Since: 0.10.31
 518  */
 519 gboolean
 520 gst_is_initialized (void)
 521 {
 522   return gst_initialized;
 523 }
 524
 525 #ifndef GST_DISABLE_REGISTRY
 526 static void
 527 add_path_func (gpointer data, gpointer user_data)
 528 {
 529   GST_INFO ("Adding plugin path: \"%s\", will scan later", (gchar *) data);
 530   _priv_gst_plugin_paths =
 531       g_list_append (_priv_gst_plugin_paths, g_strdup (data));
 532 }
 533 #endif
 534
 535 #ifndef GST_DISABLE_OPTION_PARSING
 536 static void
 537 prepare_for_load_plugin_func (gpointer data, gpointer user_data)
 538 {
 539   _priv_gst_preload_plugins =
 540       g_slist_prepend (_priv_gst_preload_plugins, g_strdup (data));
 541 }
 542 #endif
 543
 544 #ifndef GST_DISABLE_OPTION_PARSING
 545 static void
 546 split_and_iterate (const gchar * stringlist, const gchar * separator,
 547     GFunc iterator, gpointer user_data)
 548 {
 549   gchar **strings;
 550   gint j = 0;
 551   gchar *lastlist = g_strdup (stringlist);
 552
 553   while (lastlist) {
 554     strings = g_strsplit (lastlist, separator, MAX_PATH_SPLIT);
 555     g_free (lastlist);
 556     lastlist = NULL;
 557
 558     while (strings[j]) {
 559       iterator (strings[j], user_data);
 560       if (++j == MAX_PATH_SPLIT) {
 561         lastlist = g_strdup (strings[j]);
 562         j = 0;
 563         break;
 564       }
 565     }
 566     g_strfreev (strings);
 567   }
 568 }
 569 #endif
 570
 571 /* we have no fail cases yet, but maybe in the future */
 572 static gboolean
 573 init_pre (GOptionContext * context, GOptionGroup * group, gpointer data,
 574     GError ** error)
 575 {
 576   if (gst_initialized) {
 577     GST_DEBUG ("already initialized");
 578     return TRUE;
 579   }
 580
 581   g_type_init ();
 582
 583 #if !GLIB_CHECK_VERSION (2, 31, 0)
 584   /* we need threading to be enabled right here */
 585   g_assert (g_thread_get_initialized ());
 586 #endif
 587
 588 #ifndef GST_DISABLE_GST_DEBUG
 589   _priv_gst_debug_init ();
 590 #endif
 591
 592 #ifdef ENABLE_NLS
 593   setlocale (LC_ALL, "");
 594   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 595   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 596 #endif /* ENABLE_NLS */
 597
 598 #ifndef GST_DISABLE_GST_DEBUG
 599   {
 600     const gchar *debug_list;
 601
 602     if (g_getenv ("GST_DEBUG_NO_COLOR") != NULL)
 603       gst_debug_set_colored (FALSE);
 604
 605     debug_list = g_getenv ("GST_DEBUG");
 606     if (debug_list) {
 607       parse_debug_list (debug_list);
 608     }
 609   }
 610
 611   priv_gst_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
 612 #endif
 613   /* This is the earliest we can make stuff show up in the logs.
 614    * So give some useful info about GStreamer here */
 615   GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
 616   GST_INFO ("Using library installed in %s", LIBDIR);
 617
 618   /* Print some basic system details if possible (OS/architecture) */
 619 #ifdef HAVE_SYS_UTSNAME_H
 620   {
 621     struct utsname sys_details;
 622
 623     if (uname (&sys_details) == 0) {
 624       GST_INFO ("%s %s %s %s %s", sys_details.sysname,
 625           sys_details.nodename, sys_details.release, sys_details.version,
 626           sys_details.machine);
 627     }
 628   }
 629 #endif
 630
 631   return TRUE;
 632 }
 633
 634 static gboolean
 635 gst_register_core_elements (GstPlugin * plugin)
 636 {
 637   /* register some standard builtin types */
 638   if (!gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
 639           GST_TYPE_BIN) ||
 640       !gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
 641           GST_TYPE_PIPELINE)
 642       )
 643     g_assert_not_reached ();
 644
 645   return TRUE;
 646 }
 647
 648 /*
 649  * this bit handles:
 650  * - initalization of threads if we use them
 651  * - log handler
 652  * - initial output
 653  * - initializes gst_format
 654  * - registers a bunch of types for gst_objects
 655  *
 656  * - we don't have cases yet where this fails, but in the future
 657  *   we might and then it's nice to be able to return that
 658  */
 659 static gboolean
 660 init_post (GOptionContext * context, GOptionGroup * group, gpointer data,
 661     GError ** error)
 662 {
 663   GLogLevelFlags llf;
 664
 665 #ifndef GST_DISABLE_TRACE
 666   GstTrace *gst_trace;
 667 #endif /* GST_DISABLE_TRACE */
 668
 669   if (gst_initialized) {
 670     GST_DEBUG ("already initialized");
 671     return TRUE;
 672   }
 673
 674   llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
 675   g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
 676
 677   _priv_gst_quarks_initialize ();
 678   _priv_gst_memory_initialize ();
 679   _priv_gst_format_initialize ();
 680   _priv_gst_query_initialize ();
 681   _priv_gst_structure_initialize ();
 682   _priv_gst_caps_initialize ();
 683   _priv_gst_meta_initialize ();
 684
 685   g_type_class_ref (gst_object_get_type ());
 686   g_type_class_ref (gst_pad_get_type ());
 687   g_type_class_ref (gst_element_factory_get_type ());
 688   g_type_class_ref (gst_element_get_type ());
 689   g_type_class_ref (gst_type_find_factory_get_type ());
 690   g_type_class_ref (gst_bin_get_type ());
 691   g_type_class_ref (gst_bus_get_type ());
 692   g_type_class_ref (gst_task_get_type ());
 693   g_type_class_ref (gst_clock_get_type ());
 694
 695   g_type_class_ref (gst_index_factory_get_type ());
 696   gst_uri_handler_get_type ();
 697
 698   g_type_class_ref (gst_object_flags_get_type ());
 699   g_type_class_ref (gst_bin_flags_get_type ());
 700   g_type_class_ref (gst_buffer_flags_get_type ());
 701   g_type_class_ref (gst_buffer_copy_flags_get_type ());
 702   g_type_class_ref (gst_bus_flags_get_type ());
 703   g_type_class_ref (gst_bus_sync_reply_get_type ());
 704   g_type_class_ref (gst_caps_flags_get_type ());
 705   g_type_class_ref (gst_clock_return_get_type ());
 706   g_type_class_ref (gst_clock_entry_type_get_type ());
 707   g_type_class_ref (gst_clock_flags_get_type ());
 708   g_type_class_ref (gst_clock_type_get_type ());
 709   g_type_class_ref (gst_debug_graph_details_get_type ());
 710   g_type_class_ref (gst_state_get_type ());
 711   g_type_class_ref (gst_state_change_return_get_type ());
 712   g_type_class_ref (gst_state_change_get_type ());
 713   g_type_class_ref (gst_element_flags_get_type ());
 714   g_type_class_ref (gst_core_error_get_type ());
 715   g_type_class_ref (gst_library_error_get_type ());
 716   g_type_class_ref (gst_resource_error_get_type ());
 717   g_type_class_ref (gst_stream_error_get_type ());
 718   g_type_class_ref (gst_event_type_flags_get_type ());
 719   g_type_class_ref (gst_event_type_get_type ());
 720   g_type_class_ref (gst_seek_type_get_type ());
 721   g_type_class_ref (gst_seek_flags_get_type ());
 722   g_type_class_ref (gst_qos_type_get_type ());
 723   g_type_class_ref (gst_format_get_type ());
 724   g_type_class_ref (gst_index_certainty_get_type ());
 725   g_type_class_ref (gst_index_entry_type_get_type ());
 726   g_type_class_ref (gst_index_lookup_method_get_type ());
 727   g_type_class_ref (gst_assoc_flags_get_type ());
 728   g_type_class_ref (gst_index_resolver_method_get_type ());
 729   g_type_class_ref (gst_index_flags_get_type ());
 730   g_type_class_ref (gst_debug_level_get_type ());
 731   g_type_class_ref (gst_debug_color_flags_get_type ());
 732   g_type_class_ref (gst_iterator_result_get_type ());
 733   g_type_class_ref (gst_iterator_item_get_type ());
 734   g_type_class_ref (gst_message_type_get_type ());
 735   g_type_class_ref (gst_mini_object_flags_get_type ());
 736   g_type_class_ref (gst_pad_link_return_get_type ());
 737   g_type_class_ref (gst_pad_link_check_get_type ());
 738   g_type_class_ref (gst_flow_return_get_type ());
 739   g_type_class_ref (gst_pad_mode_get_type ());
 740   g_type_class_ref (gst_pad_direction_get_type ());
 741   g_type_class_ref (gst_pad_flags_get_type ());
 742   g_type_class_ref (gst_pad_presence_get_type ());
 743   g_type_class_ref (gst_pad_template_flags_get_type ());
 744   g_type_class_ref (gst_pipeline_flags_get_type ());
 745   g_type_class_ref (gst_plugin_error_get_type ());
 746   g_type_class_ref (gst_plugin_flags_get_type ());
 747   g_type_class_ref (gst_plugin_dependency_flags_get_type ());
 748   g_type_class_ref (gst_rank_get_type ());
 749   g_type_class_ref (gst_query_type_get_type ());
 750   g_type_class_ref (gst_buffering_mode_get_type ());
 751   g_type_class_ref (gst_stream_status_type_get_type ());
 752   g_type_class_ref (gst_structure_change_type_get_type ());
 753   g_type_class_ref (gst_tag_merge_mode_get_type ());
 754   g_type_class_ref (gst_tag_flag_get_type ());
 755   g_type_class_ref (gst_task_pool_get_type ());
 756   g_type_class_ref (gst_task_state_get_type ());
 757   g_type_class_ref (gst_alloc_trace_flags_get_type ());
 758   g_type_class_ref (gst_type_find_probability_get_type ());
 759   g_type_class_ref (gst_uri_error_get_type ());
 760   g_type_class_ref (gst_uri_type_get_type ());
 761   g_type_class_ref (gst_parse_error_get_type ());
 762   g_type_class_ref (gst_parse_flags_get_type ());
 763   g_type_class_ref (gst_search_mode_get_type ());
 764   g_type_class_ref (gst_progress_type_get_type ());
 765   g_type_class_ref (gst_buffer_pool_flags_get_type ());
 766   g_type_class_ref (gst_memory_flags_get_type ());
 767   g_type_class_ref (gst_map_flags_get_type ());
 768   g_type_class_ref (gst_caps_intersect_mode_get_type ());
 769   g_type_class_ref (gst_pad_probe_type_get_type ());
 770   g_type_class_ref (gst_pad_probe_return_get_type ());
 771   g_type_class_ref (gst_segment_flags_get_type ());
 772   g_type_class_ref (gst_scheduling_flags_get_type ());
 773   g_type_class_ref (gst_meta_flags_get_type ());
 774
 775   g_type_class_ref (gst_control_binding_get_type ());
 776   g_type_class_ref (gst_control_source_get_type ());
 777
 778   _priv_gst_event_initialize ();
 779   _priv_gst_buffer_initialize ();
 780   _priv_gst_message_initialize ();
 781   _priv_gst_buffer_list_initialize ();
 782   _priv_gst_sample_initialize ();
 783   _priv_gst_value_initialize ();
 784   g_type_class_ref (gst_param_spec_fraction_get_type ());
 785   _priv_gst_tag_initialize ();
 786   gst_parse_context_get_type ();
 787
 788   _priv_gst_plugin_initialize ();
 789
 790   gst_g_error_get_type ();
 791
 792   /* register core plugins */
 793   gst_plugin_register_static (GST_VERSION_MAJOR, GST_VERSION_MINOR,
 794       "staticelements", "core elements linked into the GStreamer library",
 795       gst_register_core_elements, VERSION, GST_LICENSE, PACKAGE,
 796       GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
 797
 798   /*
 799    * Any errors happening below this point are non-fatal, we therefore mark
 800    * gstreamer as being initialized, since it is the case from a plugin point of
 801    * view.
 802    *
 803    * If anything fails, it will be put back to FALSE in gst_init_check().
 804    * This allows some special plugins that would call gst_init() to not cause a
 805    * looping effect (i.e. initializing GStreamer twice).
 806    */
 807   gst_initialized = TRUE;
 808
 809   if (!gst_update_registry ())
 810     return FALSE;
 811
 812 #ifndef GST_DISABLE_TRACE
 813   _gst_trace_on = 0;
 814   if (_gst_trace_on) {
 815     gst_trace = gst_trace_new ("gst.trace", 1024);
 816     gst_trace_set_default (gst_trace);
 817   }
 818 #endif /* GST_DISABLE_TRACE */
 819
 820   GST_INFO ("GLib runtime version: %d.%d.%d", glib_major_version,
 821       glib_minor_version, glib_micro_version);
 822   GST_INFO ("GLib headers version: %d.%d.%d", GLIB_MAJOR_VERSION,
 823       GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
 824
 825   return TRUE;
 826 }
 827
 828 #ifndef GST_DISABLE_GST_DEBUG
 829 static gboolean
 830 select_all (GstPlugin * plugin, gpointer user_data)
 831 {
 832   return TRUE;
 833 }
 834
 835 static gint
 836 sort_by_category_name (gconstpointer a, gconstpointer b)
 837 {
 838   return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
 839       gst_debug_category_get_name ((GstDebugCategory *) b));
 840 }
 841
 842 static void
 843 gst_debug_help (void)
 844 {
 845   GSList *list, *walk;
 846   GList *list2, *g;
 847
 848   /* Need to ensure the registry is loaded to get debug categories */
 849   if (!init_post (NULL, NULL, NULL, NULL))
 850     exit (1);
 851
 852   list2 = gst_registry_plugin_filter (gst_registry_get_default (),
 853       select_all, FALSE, NULL);
 854
 855   /* FIXME this is gross.  why don't debug have categories PluginFeatures? */
 856   for (g = list2; g; g = g_list_next (g)) {
 857     GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
 858
 859     gst_plugin_load (plugin);
 860   }
 861   g_list_free (list2);
 862
 863   list = gst_debug_get_all_categories ();
 864   walk = list = g_slist_sort (list, sort_by_category_name);
 865
 866   g_print ("\n");
 867   g_print ("name                  level    description\n");
 868   g_print ("---------------------+--------+--------------------------------\n");
 869
 870   while (walk) {
 871     GstDebugCategory *cat = (GstDebugCategory *) walk->data;
 872
 873     if (gst_debug_is_colored ()) {
 874 #ifdef G_OS_WIN32
 875       gint color = gst_debug_construct_win_color (cat->color);
 876       const gint clear = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
 877
 878       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
 879       g_print ("%-20s", gst_debug_category_get_name (cat));
 880       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
 881       g_print (" %1d %s ", gst_debug_category_get_threshold (cat),
 882           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)));
 883       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
 884       g_print ("%s", gst_debug_category_get_description (cat));
 885       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
 886       g_print ("\n");
 887 #else /* G_OS_WIN32 */
 888       gchar *color = gst_debug_construct_term_color (cat->color);
 889
 890       g_print ("%s%-20s\033[00m  %1d %s  %s%s\033[00m\n",
 891           color,
 892           gst_debug_category_get_name (cat),
 893           gst_debug_category_get_threshold (cat),
 894           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
 895           color, gst_debug_category_get_description (cat));
 896       g_free (color);
 897 #endif /* G_OS_WIN32 */
 898     } else {
 899       g_print ("%-20s  %1d %s  %s\n", gst_debug_category_get_name (cat),
 900           gst_debug_category_get_threshold (cat),
 901           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
 902           gst_debug_category_get_description (cat));
 903     }
 904     walk = g_slist_next (walk);
 905   }
 906   g_slist_free (list);
 907   g_print ("\n");
 908 }
 909 #endif
 910
 911 #ifndef GST_DISABLE_OPTION_PARSING
 912 static gboolean
 913 parse_one_option (gint opt, const gchar * arg, GError ** err)
 914 {
 915   switch (opt) {
 916     case ARG_VERSION:
 917       g_print ("GStreamer Core Library version %s\n", PACKAGE_VERSION);
 918       exit (0);
 919     case ARG_FATAL_WARNINGS:{
 920       GLogLevelFlags fatal_mask;
 921
 922       fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
 923       fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
 924       g_log_set_always_fatal (fatal_mask);
 925       break;
 926     }
 927 #ifndef GST_DISABLE_GST_DEBUG
 928     case ARG_DEBUG_LEVEL:{
 929       GstDebugLevel tmp = GST_LEVEL_NONE;
 930
 931       tmp = (GstDebugLevel) strtol (arg, NULL, 0);
 932       if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
 933         gst_debug_set_default_threshold (tmp);
 934       }
 935       break;
 936     }
 937     case ARG_DEBUG:
 938       parse_debug_list (arg);
 939       break;
 940     case ARG_DEBUG_NO_COLOR:
 941       gst_debug_set_colored (FALSE);
 942       break;
 943     case ARG_DEBUG_DISABLE:
 944       gst_debug_set_active (FALSE);
 945       break;
 946     case ARG_DEBUG_HELP:
 947       gst_debug_help ();
 948       exit (0);
 949 #endif
 950     case ARG_PLUGIN_SPEW:
 951       break;
 952     case ARG_PLUGIN_PATH:
 953 #ifndef GST_DISABLE_REGISTRY
 954       split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func, NULL);
 955 #endif /* GST_DISABLE_REGISTRY */
 956       break;
 957     case ARG_PLUGIN_LOAD:
 958       split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
 959       break;
 960     case ARG_SEGTRAP_DISABLE:
 961       _gst_disable_segtrap = TRUE;
 962       break;
 963     case ARG_REGISTRY_UPDATE_DISABLE:
 964 #ifndef GST_DISABLE_REGISTRY
 965       _priv_gst_disable_registry_update = TRUE;
 966 #endif
 967       break;
 968     case ARG_REGISTRY_FORK_DISABLE:
 969       gst_registry_fork_set_enabled (FALSE);
 970       break;
 971     default:
 972       g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
 973           _("Unknown option"));
 974       return FALSE;
 975   }
 976
 977   return TRUE;
 978 }
 979
 980 static gboolean
 981 parse_goption_arg (const gchar * opt,
 982     const gchar * arg, gpointer data, GError ** err)
 983 {
 984   static const struct
 985   {
 986     const gchar *opt;
 987     int val;
 988   } options[] = {
 989     {
 990     "--gst-version", ARG_VERSION}, {
 991     "--gst-fatal-warnings", ARG_FATAL_WARNINGS},
 992 #ifndef GST_DISABLE_GST_DEBUG
 993     {
 994     "--gst-debug-level", ARG_DEBUG_LEVEL}, {
 995     "--gst-debug", ARG_DEBUG}, {
 996     "--gst-debug-disable", ARG_DEBUG_DISABLE}, {
 997     "--gst-debug-no-color", ARG_DEBUG_NO_COLOR}, {
 998     "--gst-debug-help", ARG_DEBUG_HELP},
 999 #endif
1000     {
1001     "--gst-plugin-spew", ARG_PLUGIN_SPEW}, {
1002     "--gst-plugin-path", ARG_PLUGIN_PATH}, {
1003     "--gst-plugin-load", ARG_PLUGIN_LOAD}, {
1004     "--gst-disable-segtrap", ARG_SEGTRAP_DISABLE}, {
1005     "--gst-disable-registry-update", ARG_REGISTRY_UPDATE_DISABLE}, {
1006     "--gst-disable-registry-fork", ARG_REGISTRY_FORK_DISABLE}, {
1007     NULL}
1008   };
1009   gint val = 0, n;
1010
1011   for (n = 0; options[n].opt; n++) {
1012     if (!strcmp (opt, options[n].opt)) {
1013       val = options[n].val;
1014       break;
1015     }
1016   }
1017
1018   return parse_one_option (val, arg, err);
1019 }
1020 #endif
1021
1022 /**
1023  * gst_deinit:
1024  *
1025  * Clean up any resources created by GStreamer in gst_init().
1026  *
1027  * It is normally not needed to call this function in a normal application
1028  * as the resources will automatically be freed when the program terminates.
1029  * This function is therefore mostly used by testsuites and other memory
1030  * profiling tools.
1031  *
1032  * After this call GStreamer (including this method) should not be used anymore.
1033  */
1034 void
1035 gst_deinit (void)
1036 {
1037   GstClock *clock;
1038
1039   GST_INFO ("deinitializing GStreamer");
1040
1041   if (gst_deinitialized) {
1042     GST_DEBUG ("already deinitialized");
1043     return;
1044   }
1045
1046   g_slist_foreach (_priv_gst_preload_plugins, (GFunc) g_free, NULL);
1047   g_slist_free (_priv_gst_preload_plugins);
1048   _priv_gst_preload_plugins = NULL;
1049
1050 #ifndef GST_DISABLE_REGISTRY
1051   g_list_foreach (_priv_gst_plugin_paths, (GFunc) g_free, NULL);
1052   g_list_free (_priv_gst_plugin_paths);
1053   _priv_gst_plugin_paths = NULL;
1054 #endif
1055
1056   clock = gst_system_clock_obtain ();
1057   gst_object_unref (clock);
1058   gst_object_unref (clock);
1059
1060   _priv_gst_registry_cleanup ();
1061
1062   g_type_class_unref (g_type_class_peek (gst_object_get_type ()));
1063   g_type_class_unref (g_type_class_peek (gst_pad_get_type ()));
1064   g_type_class_unref (g_type_class_peek (gst_element_factory_get_type ()));
1065   g_type_class_unref (g_type_class_peek (gst_element_get_type ()));
1066   g_type_class_unref (g_type_class_peek (gst_type_find_factory_get_type ()));
1067   g_type_class_unref (g_type_class_peek (gst_bin_get_type ()));
1068   g_type_class_unref (g_type_class_peek (gst_bus_get_type ()));
1069   g_type_class_unref (g_type_class_peek (gst_task_get_type ()));
1070   g_type_class_unref (g_type_class_peek (gst_index_factory_get_type ()));
1071   g_type_class_unref (g_type_class_peek (gst_object_flags_get_type ()));
1072   g_type_class_unref (g_type_class_peek (gst_bin_flags_get_type ()));
1073   g_type_class_unref (g_type_class_peek (gst_buffer_flags_get_type ()));
1074   g_type_class_unref (g_type_class_peek (gst_buffer_copy_flags_get_type ()));
1075   g_type_class_unref (g_type_class_peek (gst_bus_flags_get_type ()));
1076   g_type_class_unref (g_type_class_peek (gst_bus_sync_reply_get_type ()));
1077   g_type_class_unref (g_type_class_peek (gst_caps_flags_get_type ()));
1078   g_type_class_unref (g_type_class_peek (gst_clock_type_get_type ()));
1079   g_type_class_unref (g_type_class_peek (gst_clock_return_get_type ()));
1080   g_type_class_unref (g_type_class_peek (gst_clock_entry_type_get_type ()));
1081   g_type_class_unref (g_type_class_peek (gst_clock_flags_get_type ()));
1082   g_type_class_unref (g_type_class_peek (gst_debug_graph_details_get_type ()));
1083   g_type_class_unref (g_type_class_peek (gst_state_get_type ()));
1084   g_type_class_unref (g_type_class_peek (gst_state_change_return_get_type ()));
1085   g_type_class_unref (g_type_class_peek (gst_state_change_get_type ()));
1086   g_type_class_unref (g_type_class_peek (gst_element_flags_get_type ()));
1087   g_type_class_unref (g_type_class_peek (gst_core_error_get_type ()));
1088   g_type_class_unref (g_type_class_peek (gst_library_error_get_type ()));
1089   g_type_class_unref (g_type_class_peek (gst_plugin_dependency_flags_get_type
1090           ()));
1091   g_type_class_unref (g_type_class_peek (gst_parse_flags_get_type ()));
1092   g_type_class_unref (g_type_class_peek (gst_resource_error_get_type ()));
1093   g_type_class_unref (g_type_class_peek (gst_search_mode_get_type ()));
1094   g_type_class_unref (g_type_class_peek (gst_stream_error_get_type ()));
1095   g_type_class_unref (g_type_class_peek (gst_stream_status_type_get_type ()));
1096   g_type_class_unref (g_type_class_peek (gst_structure_change_type_get_type
1097           ()));
1098   g_type_class_unref (g_type_class_peek (gst_event_type_flags_get_type ()));
1099   g_type_class_unref (g_type_class_peek (gst_event_type_get_type ()));
1100   g_type_class_unref (g_type_class_peek (gst_seek_type_get_type ()));
1101   g_type_class_unref (g_type_class_peek (gst_seek_flags_get_type ()));
1102   g_type_class_unref (g_type_class_peek (gst_qos_type_get_type ()));
1103   g_type_class_unref (g_type_class_peek (gst_format_get_type ()));
1104   g_type_class_unref (g_type_class_peek (gst_index_certainty_get_type ()));
1105   g_type_class_unref (g_type_class_peek (gst_index_entry_type_get_type ()));
1106   g_type_class_unref (g_type_class_peek (gst_index_lookup_method_get_type ()));
1107   g_type_class_unref (g_type_class_peek (gst_assoc_flags_get_type ()));
1108   g_type_class_unref (g_type_class_peek (gst_index_resolver_method_get_type
1109           ()));
1110   g_type_class_unref (g_type_class_peek (gst_index_flags_get_type ()));
1111   g_type_class_unref (g_type_class_peek (gst_debug_level_get_type ()));
1112   g_type_class_unref (g_type_class_peek (gst_debug_color_flags_get_type ()));
1113   g_type_class_unref (g_type_class_peek (gst_iterator_result_get_type ()));
1114   g_type_class_unref (g_type_class_peek (gst_iterator_item_get_type ()));
1115   g_type_class_unref (g_type_class_peek (gst_message_type_get_type ()));
1116   g_type_class_unref (g_type_class_peek (gst_meta_flags_get_type ()));
1117   g_type_class_unref (g_type_class_peek (gst_mini_object_flags_get_type ()));
1118   g_type_class_unref (g_type_class_peek (gst_pad_link_return_get_type ()));
1119   g_type_class_unref (g_type_class_peek (gst_pad_link_check_get_type ()));
1120   g_type_class_unref (g_type_class_peek (gst_flow_return_get_type ()));
1121   g_type_class_unref (g_type_class_peek (gst_pad_mode_get_type ()));
1122   g_type_class_unref (g_type_class_peek (gst_pad_direction_get_type ()));
1123   g_type_class_unref (g_type_class_peek (gst_pad_flags_get_type ()));
1124   g_type_class_unref (g_type_class_peek (gst_pad_presence_get_type ()));
1125   g_type_class_unref (g_type_class_peek (gst_pad_template_flags_get_type ()));
1126   g_type_class_unref (g_type_class_peek (gst_pipeline_flags_get_type ()));
1127   g_type_class_unref (g_type_class_peek (gst_plugin_error_get_type ()));
1128   g_type_class_unref (g_type_class_peek (gst_plugin_flags_get_type ()));
1129   g_type_class_unref (g_type_class_peek (gst_rank_get_type ()));
1130   g_type_class_unref (g_type_class_peek (gst_query_type_get_type ()));
1131   g_type_class_unref (g_type_class_peek (gst_buffering_mode_get_type ()));
1132   g_type_class_unref (g_type_class_peek (gst_tag_merge_mode_get_type ()));
1133   g_type_class_unref (g_type_class_peek (gst_tag_flag_get_type ()));
1134   g_type_class_unref (g_type_class_peek (gst_task_state_get_type ()));
1135   g_type_class_unref (g_type_class_peek (gst_alloc_trace_flags_get_type ()));
1136   g_type_class_unref (g_type_class_peek (gst_type_find_probability_get_type
1137           ()));
1138   g_type_class_unref (g_type_class_peek (gst_uri_type_get_type ()));
1139   g_type_class_unref (g_type_class_peek (gst_uri_error_get_type ()));
1140   g_type_class_unref (g_type_class_peek (gst_parse_error_get_type ()));
1141   g_type_class_unref (g_type_class_peek (gst_param_spec_fraction_get_type ()));
1142   g_type_class_unref (g_type_class_peek (gst_progress_type_get_type ()));
1143   g_type_class_unref (g_type_class_peek (gst_buffer_pool_flags_get_type ()));
1144   g_type_class_unref (g_type_class_peek (gst_memory_flags_get_type ()));
1145   g_type_class_unref (g_type_class_peek (gst_map_flags_get_type ()));
1146   g_type_class_unref (g_type_class_peek (gst_caps_intersect_mode_get_type ()));
1147   g_type_class_unref (g_type_class_peek (gst_pad_probe_type_get_type ()));
1148   g_type_class_unref (g_type_class_peek (gst_pad_probe_return_get_type ()));
1149   g_type_class_unref (g_type_class_peek (gst_segment_flags_get_type ()));
1150   g_type_class_unref (g_type_class_peek (gst_scheduling_flags_get_type ()));
1151
1152   gst_deinitialized = TRUE;
1153   GST_INFO ("deinitialized GStreamer");
1154 }
1155
1156 /**
1157  * gst_version:
1158  * @major: (out): pointer to a guint to store the major version number
1159  * @minor: (out): pointer to a guint to store the minor version number
1160  * @micro: (out): pointer to a guint to store the micro version number
1161  * @nano:  (out): pointer to a guint to store the nano version number
1162  *
1163  * Gets the version number of the GStreamer library.
1164  */
1165 void
1166 gst_version (guint * major, guint * minor, guint * micro, guint * nano)
1167 {
1168   g_return_if_fail (major);
1169   g_return_if_fail (minor);
1170   g_return_if_fail (micro);
1171   g_return_if_fail (nano);
1172
1173   *major = GST_VERSION_MAJOR;
1174   *minor = GST_VERSION_MINOR;
1175   *micro = GST_VERSION_MICRO;
1176   *nano = GST_VERSION_NANO;
1177 }
1178
1179 /**
1180  * gst_version_string:
1181  *
1182  * This function returns a string that is useful for describing this version
1183  * of GStreamer to the outside world: user agent strings, logging, ...
1184  *
1185  * Returns: (transfer full): a newly allocated string describing this version
1186  *     of GStreamer.
1187  */
1188
1189 gchar *
1190 gst_version_string (void)
1191 {
1192   guint major, minor, micro, nano;
1193
1194   gst_version (&major, &minor, &micro, &nano);
1195   if (nano == 0)
1196     return g_strdup_printf ("GStreamer %d.%d.%d", major, minor, micro);
1197   else if (nano == 1)
1198     return g_strdup_printf ("GStreamer %d.%d.%d (GIT)", major, minor, micro);
1199   else
1200     return g_strdup_printf ("GStreamer %d.%d.%d (prerelease)", major, minor,
1201         micro);
1202 }
1203
1204 /**
1205  * gst_segtrap_is_enabled:
1206  *
1207  * Some functions in the GStreamer core might install a custom SIGSEGV handler
1208  * to better catch and report errors to the application. Currently this feature
1209  * is enabled by default when loading plugins.
1210  *
1211  * Applications might want to disable this behaviour with the
1212  * gst_segtrap_set_enabled() function. This is typically done if the application
1213  * wants to install its own handler without GStreamer interfering.
1214  *
1215  * Returns: %TRUE if GStreamer is allowed to install a custom SIGSEGV handler.
1216  *
1217  * Since: 0.10.10
1218  */
1219 gboolean
1220 gst_segtrap_is_enabled (void)
1221 {
1222   /* yeps, it's enabled when it's not disabled */
1223   return !_gst_disable_segtrap;
1224 }
1225
1226 /**
1227  * gst_segtrap_set_enabled:
1228  * @enabled: whether a custom SIGSEGV handler should be installed.
1229  *
1230  * Applications might want to disable/enable the SIGSEGV handling of
1231  * the GStreamer core. See gst_segtrap_is_enabled() for more information.
1232  *
1233  * Since: 0.10.10
1234  */
1235 void
1236 gst_segtrap_set_enabled (gboolean enabled)
1237 {
1238   _gst_disable_segtrap = !enabled;
1239 }