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 #include <mm_ta/mm_ta.h>
 122
 123
 124 #define GST_CAT_DEFAULT GST_CAT_GST_INIT
 125
 126 #define MAX_PATH_SPLIT  16
 127 #define GST_PLUGIN_SEPARATOR ","
 128
 129 static gboolean gst_initialized = FALSE;
 130 static gboolean gst_deinitialized = FALSE;
 131
 132 #ifdef G_OS_WIN32
 133 HMODULE _priv_gst_dll_handle = NULL;
 134 #endif
 135
 136 #ifndef GST_DISABLE_REGISTRY
 137 GList *_priv_gst_plugin_paths = NULL;   /* for delayed processing in post_init */
 138
 139 extern gboolean _priv_gst_disable_registry_update;
 140 #endif
 141
 142 #ifndef GST_DISABLE_GST_DEBUG
 143 extern const gchar *priv_gst_dump_dot_dir;
 144 #endif
 145
 146 /* defaults */
 147
 148 /* set to TRUE when segfaults need to be left as is */
 149 static gboolean _gst_disable_segtrap = FALSE;
 150
 151 static gboolean init_pre (GOptionContext * context, GOptionGroup * group,
 152     gpointer data, GError ** error);
 153 static gboolean init_post (GOptionContext * context, GOptionGroup * group,
 154     gpointer data, GError ** error);
 155 #ifndef GST_DISABLE_OPTION_PARSING
 156 static gboolean parse_goption_arg (const gchar * s_opt,
 157     const gchar * arg, gpointer data, GError ** err);
 158 #endif
 159
 160 GSList *_priv_gst_preload_plugins = NULL;
 161
 162 const gchar g_log_domain_gstreamer[] = "GStreamer";
 163
 164 static void
 165 debug_log_handler (const gchar * log_domain,
 166     GLogLevelFlags log_level, const gchar * message, gpointer user_data)
 167 {
 168   g_log_default_handler (log_domain, log_level, message, user_data);
 169   /* FIXME: do we still need this ? fatal errors these days are all
 170    * other than core errors */
 171   /* g_on_error_query (NULL); */
 172 }
 173
 174 enum
 175 {
 176   ARG_VERSION = 1,
 177   ARG_FATAL_WARNINGS,
 178 #ifndef GST_DISABLE_GST_DEBUG
 179   ARG_DEBUG_LEVEL,
 180   ARG_DEBUG,
 181   ARG_DEBUG_DISABLE,
 182   ARG_DEBUG_NO_COLOR,
 183   ARG_DEBUG_HELP,
 184 #endif
 185   ARG_PLUGIN_SPEW,
 186   ARG_PLUGIN_PATH,
 187   ARG_PLUGIN_LOAD,
 188   ARG_SEGTRAP_DISABLE,
 189   ARG_REGISTRY_UPDATE_DISABLE,
 190   ARG_REGISTRY_FORK_DISABLE
 191 };
 192
 193 /* debug-spec ::= category-spec [, category-spec]*
 194  * category-spec ::= category:val | val
 195  * category ::= [^:]+
 196  * val ::= [0-5]
 197  */
 198
 199 #ifndef NUL
 200 #define NUL '\0'
 201 #endif
 202
 203 #ifndef GST_DISABLE_GST_DEBUG
 204 static gboolean
 205 parse_debug_category (gchar * str, const gchar ** category)
 206 {
 207   if (!str)
 208     return FALSE;
 209
 210   /* works in place */
 211   g_strstrip (str);
 212
 213   if (str[0] != NUL) {
 214     *category = str;
 215     return TRUE;
 216   }
 217
 218   return FALSE;
 219 }
 220
 221 static gboolean
 222 parse_debug_level (gchar * str, GstDebugLevel * level)
 223 {
 224   if (!str)
 225     return FALSE;
 226
 227   /* works in place */
 228   g_strstrip (str);
 229
 230   if (str[0] != NUL && str[1] == NUL
 231       && str[0] >= '0' && str[0] < '0' + GST_LEVEL_COUNT) {
 232     *level = (GstDebugLevel) (str[0] - '0');
 233     return TRUE;
 234   }
 235
 236   return FALSE;
 237 }
 238
 239 static void
 240 parse_debug_list (const gchar * list)
 241 {
 242   gchar **split;
 243   gchar **walk;
 244
 245   g_assert (list);
 246
 247   split = g_strsplit (list, ",", 0);
 248
 249   for (walk = split; *walk; walk++) {
 250     if (strchr (*walk, ':')) {
 251       gchar **values = g_strsplit (*walk, ":", 2);
 252
 253       if (values[0] && values[1]) {
 254         GstDebugLevel level;
 255         const gchar *category;
 256
 257         if (parse_debug_category (values[0], &category)
 258             && parse_debug_level (values[1], &level))
 259           gst_debug_set_threshold_for_name (category, level);
 260       }
 261
 262       g_strfreev (values);
 263     } else {
 264       GstDebugLevel level;
 265
 266       if (parse_debug_level (*walk, &level))
 267         gst_debug_set_default_threshold (level);
 268     }
 269   }
 270
 271   g_strfreev (split);
 272 }
 273 #endif
 274
 275 #ifdef G_OS_WIN32
 276 BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);
 277 BOOL WINAPI
 278 DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
 279 {
 280   if (fdwReason == DLL_PROCESS_ATTACH)
 281     _priv_gst_dll_handle = (HMODULE) hinstDLL;
 282   return TRUE;
 283 }
 284
 285 #endif
 286
 287 /**
 288  * gst_init_get_option_group:
 289  *
 290  * Returns a #GOptionGroup with GStreamer's argument specifications. The
 291  * group is set up to use standard GOption callbacks, so when using this
 292  * group in combination with GOption parsing methods, all argument parsing
 293  * and initialization is automated.
 294  *
 295  * This function is useful if you want to integrate GStreamer with other
 296  * libraries that use GOption (see g_option_context_add_group() ).
 297  *
 298  * If you use this function, you should make sure you initialise the GLib
 299  * threading system as one of the very first things in your program
 300  * (see the example at the beginning of this section).
 301  *
 302  * Returns: (transfer full): a pointer to GStreamer's option group.
 303  */
 304
 305 GOptionGroup *
 306 gst_init_get_option_group (void)
 307 {
 308 #ifndef GST_DISABLE_OPTION_PARSING
 309   GOptionGroup *group;
 310   static const GOptionEntry gst_args[] = {
 311     {"gst-version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 312         (gpointer) parse_goption_arg, N_("Print the GStreamer version"), NULL},
 313     {"gst-fatal-warnings", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 314         (gpointer) parse_goption_arg, N_("Make all warnings fatal"), NULL},
 315 #ifndef GST_DISABLE_GST_DEBUG
 316     {"gst-debug-help", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 317           (gpointer) parse_goption_arg,
 318           N_("Print available debug categories and exit"),
 319         NULL},
 320     {"gst-debug-level", 0, 0, G_OPTION_ARG_CALLBACK,
 321           (gpointer) parse_goption_arg,
 322           N_("Default debug level from 1 (only error) to 5 (anything) or "
 323               "0 for no output"),
 324         N_("LEVEL")},
 325     {"gst-debug", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) parse_goption_arg,
 326           N_("Comma-separated list of category_name:level pairs to set "
 327               "specific levels for the individual categories. Example: "
 328               "GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
 329         N_("LIST")},
 330     {"gst-debug-no-color", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 331           (gpointer) parse_goption_arg, N_("Disable colored debugging output"),
 332         NULL},
 333     {"gst-debug-disable", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 334         (gpointer) parse_goption_arg, N_("Disable debugging"), NULL},
 335 #endif
 336     {"gst-plugin-spew", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 337           (gpointer) parse_goption_arg,
 338           N_("Enable verbose plugin loading diagnostics"),
 339         NULL},
 340     {"gst-plugin-path", 0, 0, G_OPTION_ARG_CALLBACK,
 341           (gpointer) parse_goption_arg,
 342         N_("Colon-separated paths containing plugins"), N_("PATHS")},
 343     {"gst-plugin-load", 0, 0, G_OPTION_ARG_CALLBACK,
 344           (gpointer) parse_goption_arg,
 345           N_("Comma-separated list of plugins to preload in addition to the "
 346               "list stored in environment variable GST_PLUGIN_PATH"),
 347         N_("PLUGINS")},
 348     {"gst-disable-segtrap", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 349           (gpointer) parse_goption_arg,
 350           N_("Disable trapping of segmentation faults during plugin loading"),
 351         NULL},
 352     {"gst-disable-registry-update", 0, G_OPTION_FLAG_NO_ARG,
 353           G_OPTION_ARG_CALLBACK,
 354           (gpointer) parse_goption_arg,
 355           N_("Disable updating the registry"),
 356         NULL},
 357     {"gst-disable-registry-fork", 0, G_OPTION_FLAG_NO_ARG,
 358           G_OPTION_ARG_CALLBACK,
 359           (gpointer) parse_goption_arg,
 360           N_("Disable spawning a helper process while scanning the registry"),
 361         NULL},
 362     {NULL}
 363   };
 364
 365 /* Since GLib 2.31.0 threading is always enabled and g_thread_init()
 366  * is not needed any longer and deprecated */
 367 #if !GLIB_CHECK_VERSION (2, 31, 0)
 368   /* Since GLib 2.23.2 calling g_thread_init() 'late' is allowed and is
 369    * automatically done as part of g_type_init() */
 370   if (glib_check_version (2, 23, 3)) {
 371     /* The GLib threading system must be initialised before calling any other
 372      * GLib function according to the documentation; if the application hasn't
 373      * called gst_init() yet or initialised the threading system otherwise, we
 374      * better issue a warning here (since chances are high that the application
 375      * has already called other GLib functions such as g_option_context_new() */
 376     if (!g_thread_get_initialized ()) {
 377       g_warning ("The GStreamer function gst_init_get_option_group() was\n"
 378           "\tcalled, but the GLib threading system has not been initialised\n"
 379           "\tyet, something that must happen before any other GLib function\n"
 380           "\tis called. The application needs to be fixed so that it calls\n"
 381           "\t   if (!g_thread_get_initialized ()) g_thread_init(NULL);\n"
 382           "\tas very first thing in its main() function. Please file a bug\n"
 383           "\tagainst this application.");
 384       g_thread_init (NULL);
 385     }
 386   } else {
 387     /* GLib >= 2.23.2 */
 388   }
 389 #endif
 390
 391   group = g_option_group_new ("gst", _("GStreamer Options"),
 392       _("Show GStreamer Options"), NULL, NULL);
 393   g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,
 394       (GOptionParseFunc) init_post);
 395
 396   g_option_group_add_entries (group, gst_args);
 397   g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
 398
 399   return group;
 400 #else
 401   return NULL;
 402 #endif
 403 }
 404
 405 /**
 406  * gst_init_check:
 407  * @argc: (inout) (allow-none): pointer to application's argc
 408  * @argv: (inout) (array length=argc) (allow-none): pointer to application's argv
 409  * @err: pointer to a #GError to which a message will be posted on error
 410  *
 411  * Initializes the GStreamer library, setting up internal path lists,
 412  * registering built-in elements, and loading standard plugins.
 413  *
 414  * This function will return %FALSE if GStreamer could not be initialized
 415  * for some reason.  If you want your program to fail fatally,
 416  * use gst_init() instead.
 417  *
 418  * This function should be called before calling any other GLib functions. If
 419  * this is not an option, your program must initialise the GLib thread system
 420  * using g_thread_init() before any other GLib functions are called.
 421  *
 422  * Returns: %TRUE if GStreamer could be initialized.
 423  */
 424 gboolean
 425 gst_init_check (int *argc, char **argv[], GError ** err)
 426 {
 427 #ifndef GST_DISABLE_OPTION_PARSING
 428   GOptionGroup *group;
 429   GOptionContext *ctx;
 430 #endif
 431   gboolean res;
 432
 433 #if !GLIB_CHECK_VERSION (2, 31, 0)
 434   if (!g_thread_get_initialized ())
 435     g_thread_init (NULL);
 436 #endif
 437
 438   if (gst_initialized) {
 439     GST_DEBUG ("already initialized gst");
 440     return TRUE;
 441   }
 442 #ifndef GST_DISABLE_OPTION_PARSING
 443   ctx = g_option_context_new ("- GStreamer initialization");
 444   g_option_context_set_ignore_unknown_options (ctx, TRUE);
 445   group = gst_init_get_option_group ();
 446   g_option_context_add_group (ctx, group);
 447   res = g_option_context_parse (ctx, argc, argv, err);
 448   g_option_context_free (ctx);
 449 #else
 450   init_pre (NULL, NULL, NULL, NULL);
 451   init_post (NULL, NULL, NULL, NULL);
 452   res = TRUE;
 453 #endif
 454
 455   gst_initialized = res;
 456
 457   if (res) {
 458     GST_INFO ("initialized GStreamer successfully");
 459   } else {
 460     GST_INFO ("failed to initialize GStreamer");
 461   }
 462
 463   return res;
 464 }
 465
 466 /**
 467  * gst_init:
 468  * @argc: (inout) (allow-none): pointer to application's argc
 469  * @argv: (inout) (array length=argc) (allow-none): pointer to application's argv
 470  *
 471  * Initializes the GStreamer library, setting up internal path lists,
 472  * registering built-in elements, and loading standard plugins.
 473  *
 474  * Unless the plugin registry is disabled at compile time, the registry will be
 475  * loaded. By default this will also check if the registry cache needs to be
 476  * updated and rescan all plugins if needed. See gst_update_registry() for
 477  * details and section
 478  * <link linkend="gst-running">Running GStreamer Applications</link>
 479  * for how to disable automatic registry updates.
 480  *
 481  * This function should be called before calling any other GLib functions. If
 482  * this is not an option, your program must initialise the GLib thread system
 483  * using g_thread_init() before any other GLib functions are called.
 484  *
 485  * <note><para>
 486  * This function will terminate your program if it was unable to initialize
 487  * GStreamer for some reason.  If you want your program to fall back,
 488  * use gst_init_check() instead.
 489  * </para></note>
 490  *
 491  * WARNING: This function does not work in the same way as corresponding
 492  * functions in other glib-style libraries, such as gtk_init().  In
 493  * particular, unknown command line options cause this function to
 494  * abort program execution.
 495  */
 496 void
 497 gst_init (int *argc, char **argv[])
 498 {
 499   GError *err = NULL;
 500
 501   MMTA_INIT();
 502
 503 __ta__("gst_init",
 504   if (!gst_init_check (argc, argv, &err)) {
 505     g_print ("Could not initialize GStreamer: %s\n",
 506         err ? err->message : "unknown error occurred");
 507     if (err) {
 508       g_error_free (err);
 509     }
 510     exit (1);
 511   }
 512 )
 513
 514 }
 515
 516 /**
 517  * gst_is_initialized:
 518  *
 519  * Use this function to check if GStreamer has been initialized with gst_init()
 520  * or gst_init_check().
 521  *
 522  * Returns: TRUE if initialization has been done, FALSE otherwise.
 523  *
 524  * Since: 0.10.31
 525  */
 526 gboolean
 527 gst_is_initialized (void)
 528 {
 529   return gst_initialized;
 530 }
 531
 532 #ifndef GST_DISABLE_REGISTRY
 533 static void
 534 add_path_func (gpointer data, gpointer user_data)
 535 {
 536   GST_INFO ("Adding plugin path: \"%s\", will scan later", (gchar *) data);
 537   _priv_gst_plugin_paths =
 538       g_list_append (_priv_gst_plugin_paths, g_strdup (data));
 539 }
 540 #endif
 541
 542 #ifndef GST_DISABLE_OPTION_PARSING
 543 static void
 544 prepare_for_load_plugin_func (gpointer data, gpointer user_data)
 545 {
 546   _priv_gst_preload_plugins =
 547       g_slist_prepend (_priv_gst_preload_plugins, g_strdup (data));
 548 }
 549 #endif
 550
 551 #ifndef GST_DISABLE_OPTION_PARSING
 552 static void
 553 split_and_iterate (const gchar * stringlist, const gchar * separator,
 554     GFunc iterator, gpointer user_data)
 555 {
 556   gchar **strings;
 557   gint j = 0;
 558   gchar *lastlist = g_strdup (stringlist);
 559
 560   while (lastlist) {
 561     strings = g_strsplit (lastlist, separator, MAX_PATH_SPLIT);
 562     g_free (lastlist);
 563     lastlist = NULL;
 564
 565     while (strings[j]) {
 566       iterator (strings[j], user_data);
 567       if (++j == MAX_PATH_SPLIT) {
 568         lastlist = g_strdup (strings[j]);
 569         j = 0;
 570         break;
 571       }
 572     }
 573     g_strfreev (strings);
 574   }
 575 }
 576 #endif
 577
 578 /* we have no fail cases yet, but maybe in the future */
 579 static gboolean
 580 init_pre (GOptionContext * context, GOptionGroup * group, gpointer data,
 581     GError ** error)
 582 {
 583   if (gst_initialized) {
 584     GST_DEBUG ("already initialized");
 585     return TRUE;
 586   }
 587
 588   g_type_init ();
 589
 590 #if !GLIB_CHECK_VERSION (2, 31, 0)
 591   /* we need threading to be enabled right here */
 592   g_assert (g_thread_get_initialized ());
 593 #endif
 594
 595   _gst_debug_init ();
 596
 597 #ifdef ENABLE_NLS
 598   setlocale (LC_ALL, "");
 599   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 600   bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 601 #endif /* ENABLE_NLS */
 602
 603 #ifndef GST_DISABLE_GST_DEBUG
 604   {
 605     const gchar *debug_list;
 606
 607     if (g_getenv ("GST_DEBUG_NO_COLOR") != NULL)
 608       gst_debug_set_colored (FALSE);
 609
 610     debug_list = g_getenv ("GST_DEBUG");
 611     if (debug_list) {
 612       parse_debug_list (debug_list);
 613     }
 614   }
 615
 616   priv_gst_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
 617 #endif
 618   /* This is the earliest we can make stuff show up in the logs.
 619    * So give some useful info about GStreamer here */
 620   GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
 621   GST_INFO ("Using library installed in %s", LIBDIR);
 622
 623   /* Print some basic system details if possible (OS/architecture) */
 624 #ifdef HAVE_SYS_UTSNAME_H
 625   {
 626     struct utsname sys_details;
 627
 628     if (uname (&sys_details) == 0) {
 629       GST_INFO ("%s %s %s %s %s", sys_details.sysname,
 630           sys_details.nodename, sys_details.release, sys_details.version,
 631           sys_details.machine);
 632     }
 633   }
 634 #endif
 635
 636   return TRUE;
 637 }
 638
 639 static gboolean
 640 gst_register_core_elements (GstPlugin * plugin)
 641 {
 642   /* register some standard builtin types */
 643   if (!gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
 644           GST_TYPE_BIN) ||
 645       !gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
 646           GST_TYPE_PIPELINE)
 647       )
 648     g_assert_not_reached ();
 649
 650   return TRUE;
 651 }
 652
 653 /*
 654  * this bit handles:
 655  * - initalization of threads if we use them
 656  * - log handler
 657  * - initial output
 658  * - initializes gst_format
 659  * - registers a bunch of types for gst_objects
 660  *
 661  * - we don't have cases yet where this fails, but in the future
 662  *   we might and then it's nice to be able to return that
 663  */
 664 static gboolean
 665 init_post (GOptionContext * context, GOptionGroup * group, gpointer data,
 666     GError ** error)
 667 {
 668   GLogLevelFlags llf;
 669
 670 #ifndef GST_DISABLE_TRACE
 671   GstTrace *gst_trace;
 672 #endif /* GST_DISABLE_TRACE */
 673
 674   if (gst_initialized) {
 675     GST_DEBUG ("already initialized");
 676     return TRUE;
 677   }
 678
 679   llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
 680   g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
 681
 682   _priv_gst_quarks_initialize ();
 683   _gst_format_initialize ();
 684   _gst_query_initialize ();
 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_flag_get_type ());
 701   g_type_class_ref (gst_buffer_copy_flags_get_type ());
 702   g_type_class_ref (gst_buffer_list_item_get_type ());
 703   g_type_class_ref (gst_bus_flags_get_type ());
 704   g_type_class_ref (gst_bus_sync_reply_get_type ());
 705   g_type_class_ref (gst_caps_flags_get_type ());
 706   g_type_class_ref (gst_clock_return_get_type ());
 707   g_type_class_ref (gst_clock_entry_type_get_type ());
 708   g_type_class_ref (gst_clock_flags_get_type ());
 709   g_type_class_ref (gst_clock_type_get_type ());
 710   g_type_class_ref (gst_debug_graph_details_get_type ());
 711   g_type_class_ref (gst_state_get_type ());
 712   g_type_class_ref (gst_state_change_return_get_type ());
 713   g_type_class_ref (gst_state_change_get_type ());
 714   g_type_class_ref (gst_element_flags_get_type ());
 715   g_type_class_ref (gst_core_error_get_type ());
 716   g_type_class_ref (gst_library_error_get_type ());
 717   g_type_class_ref (gst_resource_error_get_type ());
 718   g_type_class_ref (gst_stream_error_get_type ());
 719   g_type_class_ref (gst_event_type_flags_get_type ());
 720   g_type_class_ref (gst_event_type_get_type ());
 721   g_type_class_ref (gst_seek_type_get_type ());
 722   g_type_class_ref (gst_seek_flags_get_type ());
 723   g_type_class_ref (gst_qos_type_get_type ());
 724   g_type_class_ref (gst_format_get_type ());
 725   g_type_class_ref (gst_index_certainty_get_type ());
 726   g_type_class_ref (gst_index_entry_type_get_type ());
 727   g_type_class_ref (gst_index_lookup_method_get_type ());
 728   g_type_class_ref (gst_assoc_flags_get_type ());
 729   g_type_class_ref (gst_index_resolver_method_get_type ());
 730   g_type_class_ref (gst_index_flags_get_type ());
 731   g_type_class_ref (gst_debug_level_get_type ());
 732   g_type_class_ref (gst_debug_color_flags_get_type ());
 733   g_type_class_ref (gst_iterator_result_get_type ());
 734   g_type_class_ref (gst_iterator_item_get_type ());
 735   g_type_class_ref (gst_message_type_get_type ());
 736   g_type_class_ref (gst_mini_object_flags_get_type ());
 737   g_type_class_ref (gst_pad_link_return_get_type ());
 738   g_type_class_ref (gst_pad_link_check_get_type ());
 739   g_type_class_ref (gst_flow_return_get_type ());
 740   g_type_class_ref (gst_activate_mode_get_type ());
 741   g_type_class_ref (gst_pad_direction_get_type ());
 742   g_type_class_ref (gst_pad_flags_get_type ());
 743   g_type_class_ref (gst_pad_presence_get_type ());
 744   g_type_class_ref (gst_pad_template_flags_get_type ());
 745   g_type_class_ref (gst_pipeline_flags_get_type ());
 746   g_type_class_ref (gst_plugin_error_get_type ());
 747   g_type_class_ref (gst_plugin_flags_get_type ());
 748   g_type_class_ref (gst_plugin_dependency_flags_get_type ());
 749   g_type_class_ref (gst_rank_get_type ());
 750   g_type_class_ref (gst_query_type_get_type ());
 751   g_type_class_ref (gst_buffering_mode_get_type ());
 752   g_type_class_ref (gst_stream_status_type_get_type ());
 753   g_type_class_ref (gst_structure_change_type_get_type ());
 754   g_type_class_ref (gst_tag_merge_mode_get_type ());
 755   g_type_class_ref (gst_tag_flag_get_type ());
 756   g_type_class_ref (gst_task_pool_get_type ());
 757   g_type_class_ref (gst_task_state_get_type ());
 758   g_type_class_ref (gst_alloc_trace_flags_get_type ());
 759   g_type_class_ref (gst_type_find_probability_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_caps_intersect_mode_get_type ());
 766
 767   gst_structure_get_type ();
 768   _gst_value_initialize ();
 769   g_type_class_ref (gst_param_spec_fraction_get_type ());
 770   gst_caps_get_type ();
 771   _gst_event_initialize ();
 772   _gst_buffer_initialize ();
 773   _gst_buffer_list_initialize ();
 774   gst_buffer_list_iterator_get_type ();
 775   _gst_message_initialize ();
 776   _gst_tag_initialize ();
 777   gst_parse_context_get_type ();
 778
 779   _gst_plugin_initialize ();
 780
 781   gst_g_error_get_type ();
 782
 783   /* register core plugins */
 784   gst_plugin_register_static (GST_VERSION_MAJOR, GST_VERSION_MINOR,
 785       "staticelements", "core elements linked into the GStreamer library",
 786       gst_register_core_elements, VERSION, GST_LICENSE, PACKAGE,
 787       GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);
 788
 789   /*
 790    * Any errors happening below this point are non-fatal, we therefore mark
 791    * gstreamer as being initialized, since it is the case from a plugin point of
 792    * view.
 793    *
 794    * If anything fails, it will be put back to FALSE in gst_init_check().
 795    * This allows some special plugins that would call gst_init() to not cause a
 796    * looping effect (i.e. initializing GStreamer twice).
 797    */
 798   gst_initialized = TRUE;
 799
 800   if (!gst_update_registry ())
 801     return FALSE;
 802
 803 #ifndef GST_DISABLE_TRACE
 804   _gst_trace_on = 0;
 805   if (_gst_trace_on) {
 806     gst_trace = gst_trace_new ("gst.trace", 1024);
 807     gst_trace_set_default (gst_trace);
 808   }
 809 #endif /* GST_DISABLE_TRACE */
 810
 811   GST_INFO ("GLib runtime version: %d.%d.%d", glib_major_version,
 812       glib_minor_version, glib_micro_version);
 813   GST_INFO ("GLib headers version: %d.%d.%d", GLIB_MAJOR_VERSION,
 814       GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);
 815
 816   return TRUE;
 817 }
 818
 819 #ifndef GST_DISABLE_GST_DEBUG
 820 static gboolean
 821 select_all (GstPlugin * plugin, gpointer user_data)
 822 {
 823   return TRUE;
 824 }
 825
 826 static gint
 827 sort_by_category_name (gconstpointer a, gconstpointer b)
 828 {
 829   return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
 830       gst_debug_category_get_name ((GstDebugCategory *) b));
 831 }
 832
 833 static void
 834 gst_debug_help (void)
 835 {
 836   GSList *list, *walk;
 837   GList *list2, *g;
 838
 839   /* Need to ensure the registry is loaded to get debug categories */
 840   if (!init_post (NULL, NULL, NULL, NULL))
 841     exit (1);
 842
 843   list2 = gst_registry_plugin_filter (gst_registry_get_default (),
 844       select_all, FALSE, NULL);
 845
 846   /* FIXME this is gross.  why don't debug have categories PluginFeatures? */
 847   for (g = list2; g; g = g_list_next (g)) {
 848     GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
 849
 850     gst_plugin_load (plugin);
 851   }
 852   g_list_free (list2);
 853
 854   list = gst_debug_get_all_categories ();
 855   walk = list = g_slist_sort (list, sort_by_category_name);
 856
 857   g_print ("\n");
 858   g_print ("name                  level    description\n");
 859   g_print ("---------------------+--------+--------------------------------\n");
 860
 861   while (walk) {
 862     GstDebugCategory *cat = (GstDebugCategory *) walk->data;
 863
 864     if (gst_debug_is_colored ()) {
 865 #ifdef G_OS_WIN32
 866       gint color = gst_debug_construct_win_color (cat->color);
 867       const gint clear = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
 868
 869       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
 870       g_print ("%-20s", gst_debug_category_get_name (cat));
 871       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
 872       g_print (" %1d %s ", gst_debug_category_get_threshold (cat),
 873           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)));
 874       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color);
 875       g_print ("%s", gst_debug_category_get_description (cat));
 876       SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), clear);
 877       g_print ("\n");
 878 #else /* G_OS_WIN32 */
 879       gchar *color = gst_debug_construct_term_color (cat->color);
 880
 881       g_print ("%s%-20s\033[00m  %1d %s  %s%s\033[00m\n",
 882           color,
 883           gst_debug_category_get_name (cat),
 884           gst_debug_category_get_threshold (cat),
 885           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
 886           color, gst_debug_category_get_description (cat));
 887       g_free (color);
 888 #endif /* G_OS_WIN32 */
 889     } else {
 890       g_print ("%-20s  %1d %s  %s\n", gst_debug_category_get_name (cat),
 891           gst_debug_category_get_threshold (cat),
 892           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
 893           gst_debug_category_get_description (cat));
 894     }
 895     walk = g_slist_next (walk);
 896   }
 897   g_slist_free (list);
 898   g_print ("\n");
 899 }
 900 #endif
 901
 902 #ifndef GST_DISABLE_OPTION_PARSING
 903 static gboolean
 904 parse_one_option (gint opt, const gchar * arg, GError ** err)
 905 {
 906   switch (opt) {
 907     case ARG_VERSION:
 908       g_print ("GStreamer Core Library version %s\n", PACKAGE_VERSION);
 909       exit (0);
 910     case ARG_FATAL_WARNINGS:{
 911       GLogLevelFlags fatal_mask;
 912
 913       fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
 914       fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
 915       g_log_set_always_fatal (fatal_mask);
 916       break;
 917     }
 918 #ifndef GST_DISABLE_GST_DEBUG
 919     case ARG_DEBUG_LEVEL:{
 920       GstDebugLevel tmp = GST_LEVEL_NONE;
 921
 922       tmp = (GstDebugLevel) strtol (arg, NULL, 0);
 923       if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
 924         gst_debug_set_default_threshold (tmp);
 925       }
 926       break;
 927     }
 928     case ARG_DEBUG:
 929       parse_debug_list (arg);
 930       break;
 931     case ARG_DEBUG_NO_COLOR:
 932       gst_debug_set_colored (FALSE);
 933       break;
 934     case ARG_DEBUG_DISABLE:
 935       gst_debug_set_active (FALSE);
 936       break;
 937     case ARG_DEBUG_HELP:
 938       gst_debug_help ();
 939       exit (0);
 940 #endif
 941     case ARG_PLUGIN_SPEW:
 942       break;
 943     case ARG_PLUGIN_PATH:
 944 #ifndef GST_DISABLE_REGISTRY
 945       split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func, NULL);
 946 #endif /* GST_DISABLE_REGISTRY */
 947       break;
 948     case ARG_PLUGIN_LOAD:
 949       split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
 950       break;
 951     case ARG_SEGTRAP_DISABLE:
 952       _gst_disable_segtrap = TRUE;
 953       break;
 954     case ARG_REGISTRY_UPDATE_DISABLE:
 955 #ifndef GST_DISABLE_REGISTRY
 956       _priv_gst_disable_registry_update = TRUE;
 957 #endif
 958       break;
 959     case ARG_REGISTRY_FORK_DISABLE:
 960       gst_registry_fork_set_enabled (FALSE);
 961       break;
 962     default:
 963       g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
 964           _("Unknown option"));
 965       return FALSE;
 966   }
 967
 968   return TRUE;
 969 }
 970
 971 static gboolean
 972 parse_goption_arg (const gchar * opt,
 973     const gchar * arg, gpointer data, GError ** err)
 974 {
 975   static const struct
 976   {
 977     const gchar *opt;
 978     int val;
 979   } options[] = {
 980     {
 981     "--gst-version", ARG_VERSION}, {
 982     "--gst-fatal-warnings", ARG_FATAL_WARNINGS},
 983 #ifndef GST_DISABLE_GST_DEBUG
 984     {
 985     "--gst-debug-level", ARG_DEBUG_LEVEL}, {
 986     "--gst-debug", ARG_DEBUG}, {
 987     "--gst-debug-disable", ARG_DEBUG_DISABLE}, {
 988     "--gst-debug-no-color", ARG_DEBUG_NO_COLOR}, {
 989     "--gst-debug-help", ARG_DEBUG_HELP},
 990 #endif
 991     {
 992     "--gst-plugin-spew", ARG_PLUGIN_SPEW}, {
 993     "--gst-plugin-path", ARG_PLUGIN_PATH}, {
 994     "--gst-plugin-load", ARG_PLUGIN_LOAD}, {
 995     "--gst-disable-segtrap", ARG_SEGTRAP_DISABLE}, {
 996     "--gst-disable-registry-update", ARG_REGISTRY_UPDATE_DISABLE}, {
 997     "--gst-disable-registry-fork", ARG_REGISTRY_FORK_DISABLE}, {
 998     NULL}
 999   };
1000   gint val = 0, n;
1001
1002   for (n = 0; options[n].opt; n++) {
1003     if (!strcmp (opt, options[n].opt)) {
1004       val = options[n].val;
1005       break;
1006     }
1007   }
1008
1009   return parse_one_option (val, arg, err);
1010 }
1011 #endif
1012
1013 /**
1014  * gst_deinit:
1015  *
1016  * Clean up any resources created by GStreamer in gst_init().
1017  *
1018  * It is normally not needed to call this function in a normal application
1019  * as the resources will automatically be freed when the program terminates.
1020  * This function is therefore mostly used by testsuites and other memory
1021  * profiling tools.
1022  *
1023  * After this call GStreamer (including this method) should not be used anymore.
1024  */
1025 void
1026 gst_deinit (void)
1027 {
1028   GstClock *clock;
1029
1030   GST_INFO ("deinitializing GStreamer");
1031
1032   if (gst_deinitialized) {
1033     GST_DEBUG ("already deinitialized");
1034     return;
1035   }
1036
1037   g_slist_foreach (_priv_gst_preload_plugins, (GFunc) g_free, NULL);
1038   g_slist_free (_priv_gst_preload_plugins);
1039   _priv_gst_preload_plugins = NULL;
1040
1041 #ifndef GST_DISABLE_REGISTRY
1042   g_list_foreach (_priv_gst_plugin_paths, (GFunc) g_free, NULL);
1043   g_list_free (_priv_gst_plugin_paths);
1044   _priv_gst_plugin_paths = NULL;
1045 #endif
1046
1047   clock = gst_system_clock_obtain ();
1048   gst_object_unref (clock);
1049   gst_object_unref (clock);
1050
1051   _priv_gst_registry_cleanup ();
1052
1053   g_type_class_unref (g_type_class_peek (gst_object_get_type ()));
1054   g_type_class_unref (g_type_class_peek (gst_pad_get_type ()));
1055   g_type_class_unref (g_type_class_peek (gst_element_factory_get_type ()));
1056   g_type_class_unref (g_type_class_peek (gst_element_get_type ()));
1057   g_type_class_unref (g_type_class_peek (gst_type_find_factory_get_type ()));
1058   g_type_class_unref (g_type_class_peek (gst_bin_get_type ()));
1059   g_type_class_unref (g_type_class_peek (gst_bus_get_type ()));
1060   g_type_class_unref (g_type_class_peek (gst_task_get_type ()));
1061   g_type_class_unref (g_type_class_peek (gst_index_factory_get_type ()));
1062   g_type_class_unref (g_type_class_peek (gst_object_flags_get_type ()));
1063   g_type_class_unref (g_type_class_peek (gst_bin_flags_get_type ()));
1064   g_type_class_unref (g_type_class_peek (gst_buffer_flag_get_type ()));
1065   g_type_class_unref (g_type_class_peek (gst_buffer_copy_flags_get_type ()));
1066   g_type_class_unref (g_type_class_peek (gst_buffer_list_item_get_type ()));
1067   g_type_class_unref (g_type_class_peek (gst_bus_flags_get_type ()));
1068   g_type_class_unref (g_type_class_peek (gst_bus_sync_reply_get_type ()));
1069   g_type_class_unref (g_type_class_peek (gst_caps_flags_get_type ()));
1070   g_type_class_unref (g_type_class_peek (gst_clock_type_get_type ()));
1071   g_type_class_unref (g_type_class_peek (gst_clock_return_get_type ()));
1072   g_type_class_unref (g_type_class_peek (gst_clock_entry_type_get_type ()));
1073   g_type_class_unref (g_type_class_peek (gst_clock_flags_get_type ()));
1074   g_type_class_unref (g_type_class_peek (gst_debug_graph_details_get_type ()));
1075   g_type_class_unref (g_type_class_peek (gst_state_get_type ()));
1076   g_type_class_unref (g_type_class_peek (gst_state_change_return_get_type ()));
1077   g_type_class_unref (g_type_class_peek (gst_state_change_get_type ()));
1078   g_type_class_unref (g_type_class_peek (gst_element_flags_get_type ()));
1079   g_type_class_unref (g_type_class_peek (gst_core_error_get_type ()));
1080   g_type_class_unref (g_type_class_peek (gst_library_error_get_type ()));
1081   g_type_class_unref (g_type_class_peek (gst_plugin_dependency_flags_get_type
1082           ()));
1083   g_type_class_unref (g_type_class_peek (gst_parse_flags_get_type ()));
1084   g_type_class_unref (g_type_class_peek (gst_resource_error_get_type ()));
1085   g_type_class_unref (g_type_class_peek (gst_search_mode_get_type ()));
1086   g_type_class_unref (g_type_class_peek (gst_stream_error_get_type ()));
1087   g_type_class_unref (g_type_class_peek (gst_stream_status_type_get_type ()));
1088   g_type_class_unref (g_type_class_peek (gst_structure_change_type_get_type
1089           ()));
1090   g_type_class_unref (g_type_class_peek (gst_event_type_flags_get_type ()));
1091   g_type_class_unref (g_type_class_peek (gst_event_type_get_type ()));
1092   g_type_class_unref (g_type_class_peek (gst_seek_type_get_type ()));
1093   g_type_class_unref (g_type_class_peek (gst_seek_flags_get_type ()));
1094   g_type_class_unref (g_type_class_peek (gst_qos_type_get_type ()));
1095   g_type_class_unref (g_type_class_peek (gst_format_get_type ()));
1096   g_type_class_unref (g_type_class_peek (gst_index_certainty_get_type ()));
1097   g_type_class_unref (g_type_class_peek (gst_index_entry_type_get_type ()));
1098   g_type_class_unref (g_type_class_peek (gst_index_lookup_method_get_type ()));
1099   g_type_class_unref (g_type_class_peek (gst_assoc_flags_get_type ()));
1100   g_type_class_unref (g_type_class_peek (gst_index_resolver_method_get_type
1101           ()));
1102   g_type_class_unref (g_type_class_peek (gst_index_flags_get_type ()));
1103   g_type_class_unref (g_type_class_peek (gst_debug_level_get_type ()));
1104   g_type_class_unref (g_type_class_peek (gst_debug_color_flags_get_type ()));
1105   g_type_class_unref (g_type_class_peek (gst_iterator_result_get_type ()));
1106   g_type_class_unref (g_type_class_peek (gst_iterator_item_get_type ()));
1107   g_type_class_unref (g_type_class_peek (gst_message_type_get_type ()));
1108   g_type_class_unref (g_type_class_peek (gst_mini_object_flags_get_type ()));
1109   g_type_class_unref (g_type_class_peek (gst_pad_link_return_get_type ()));
1110   g_type_class_unref (g_type_class_peek (gst_pad_link_check_get_type ()));
1111   g_type_class_unref (g_type_class_peek (gst_flow_return_get_type ()));
1112   g_type_class_unref (g_type_class_peek (gst_activate_mode_get_type ()));
1113   g_type_class_unref (g_type_class_peek (gst_pad_direction_get_type ()));
1114   g_type_class_unref (g_type_class_peek (gst_pad_flags_get_type ()));
1115   g_type_class_unref (g_type_class_peek (gst_pad_presence_get_type ()));
1116   g_type_class_unref (g_type_class_peek (gst_pad_template_flags_get_type ()));
1117   g_type_class_unref (g_type_class_peek (gst_pipeline_flags_get_type ()));
1118   g_type_class_unref (g_type_class_peek (gst_plugin_error_get_type ()));
1119   g_type_class_unref (g_type_class_peek (gst_plugin_flags_get_type ()));
1120   g_type_class_unref (g_type_class_peek (gst_rank_get_type ()));
1121   g_type_class_unref (g_type_class_peek (gst_query_type_get_type ()));
1122   g_type_class_unref (g_type_class_peek (gst_buffering_mode_get_type ()));
1123   g_type_class_unref (g_type_class_peek (gst_tag_merge_mode_get_type ()));
1124   g_type_class_unref (g_type_class_peek (gst_tag_flag_get_type ()));
1125   g_type_class_unref (g_type_class_peek (gst_task_state_get_type ()));
1126   g_type_class_unref (g_type_class_peek (gst_alloc_trace_flags_get_type ()));
1127   g_type_class_unref (g_type_class_peek (gst_type_find_probability_get_type
1128           ()));
1129   g_type_class_unref (g_type_class_peek (gst_uri_type_get_type ()));
1130   g_type_class_unref (g_type_class_peek (gst_parse_error_get_type ()));
1131   g_type_class_unref (g_type_class_peek (gst_param_spec_fraction_get_type ()));
1132   g_type_class_unref (g_type_class_peek (gst_progress_type_get_type ()));
1133   g_type_class_unref (g_type_class_peek (gst_caps_intersect_mode_get_type ()));
1134
1135   gst_deinitialized = TRUE;
1136   GST_INFO ("deinitialized GStreamer");
1137
1138   MMTA_RELEASE();
1139
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 }