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  * @see_also: Check out both <ulink url="http://www.cse.ogi.edu/sysl/">OGI's
  28  *            pipeline</ulink> and Microsoft's DirectShow for some background.
  29  *
  30  * GStreamer is a framework for constructing graphs of various filters
  31  * (termed elements here) that will handle streaming media.  Any discreet
  32  * (packetizable) media type is supported, with provisions for automatically
  33  * determining source type.  Formatting/framing information is provided with
  34  * a powerful negotiation framework.  Plugins are heavily used to provide for
  35  * all elements, allowing one to construct plugins outside of the GST
  36  * library, even released binary-only if license require (please don't).
  37  *
  38  * GStreamer borrows heavily from both the <ulink
  39  * url="http://www.cse.ogi.edu/sysl/">OGI media pipeline</ulink> and
  40  * Microsoft's DirectShow, hopefully taking the best of both and leaving the
  41  * cruft behind. Its interface is slowly getting stable.
  42  *
  43  * The <application>GStreamer</application> library should be initialized with
  44  * gst_init() before it can be used. You should pass pointers to the main argc
  45  * and argv variables so that GStreamer can process its own command line
  46  * options, as shown in the following example.
  47  *
  48  * <example>
  49  * <title>Initializing the gstreamer library</title>
  50  * <programlisting language="c">
  51  * int
  52  * main (int argc, char *argv[])
  53  * {
  54  *   // initialize the GStreamer library
  55  *   gst_init (&amp;argc, &amp;argv);
  56  *   ...
  57  * }
  58  * </programlisting>
  59  * </example>
  60  *
  61  * It's allowed to pass two NULL pointers to gst_init() in case you don't want
  62  * to pass the command line args to GStreamer.
  63  *
  64  * You can also use GOption to initialize your own parameters as shown in
  65  * the next code fragment:
  66  * <example>
  67  * <title>Initializing own parameters when initializing gstreamer</title>
  68  * <programlisting>
  69  * static gboolean stats = FALSE;
  70  * ...
  71  * int
  72  * main (int argc, char *argv[])
  73  * {
  74  *  GOptionEntry options[] = {
  75  *   {"tags", 't', 0, G_OPTION_ARG_NONE, &amp;tags,
  76  *       N_("Output tags (also known as metadata)"), NULL},
  77  *   {NULL}
  78  *  };
  79  *  // must initialise the threading system before using any other GLib funtion
  80  *  if (!g_thread_supported ())
  81  *    g_thread_init (NULL);
  82  *  ctx = g_option_context_new ("[ADDITIONAL ARGUMENTS]");
  83  *  g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);
  84  *  g_option_context_add_group (ctx, gst_init_get_option_group ());
  85  *  if (!g_option_context_parse (ctx, &amp;argc, &amp;argv, &amp;err)) {
  86  *    g_print ("Error initializing: &percnt;s\n", GST_STR_NULL (err->message));
  87  *    exit (1);
  88  *  }
  89  *  g_option_context_free (ctx);
  90  * ...
  91  * }
  92  * </programlisting>
  93  * </example>
  94  *
  95  * Use gst_version() to query the library version at runtime or use the
  96  * GST_VERSION_* macros to find the version at compile time. Optionally
  97  * gst_version_string() returns a printable string.
  98  *
  99  * The gst_deinit() call is used to clean up all internal resources used
 100  * by <application>GStreamer</application>. It is mostly used in unit tests
 101  * to check for leaks.
 102  *
 103  * Last reviewed on 2006-08-11 (0.10.10)
 104  */
 105
 106 #include "gst_private.h"
 107 #include <stdlib.h>
 108 #include <stdio.h>
 109 #include <sys/types.h>
 110 #ifdef HAVE_FORK
 111 #include <sys/wait.h>
 112 #endif /* HAVE_FORK */
 113 #ifdef HAVE_SYS_UTSNAME_H
 114 #include <sys/utsname.h>
 115 #endif
 116 #ifdef HAVE_UNISTD_H
 117 #include <unistd.h>
 118 #endif
 119
 120 #include "gst-i18n-lib.h"
 121 #include <locale.h>             /* for LC_ALL */
 122
 123 #include "gst.h"
 124
 125 #define GST_CAT_DEFAULT GST_CAT_GST_INIT
 126
 127 #define MAX_PATH_SPLIT  16
 128 #define GST_PLUGIN_SEPARATOR ","
 129
 130 static gboolean gst_initialized = FALSE;
 131
 132 #ifndef GST_DISABLE_REGISTRY
 133 static GList *plugin_paths = NULL;      /* for delayed processing in post_init */
 134 #endif
 135
 136 extern gint _gst_trace_on;
 137
 138 #ifndef GST_DISABLE_GST_DEBUG
 139 extern const gchar *priv_gst_dump_dot_dir;
 140 #endif
 141
 142 /* defaults */
 143 #ifdef HAVE_FORK
 144 #define DEFAULT_FORK TRUE
 145 #else
 146 #define DEFAULT_FORK FALSE
 147 #endif /* HAVE_FORK */
 148
 149 /* set to TRUE when segfaults need to be left as is */
 150 static gboolean _gst_disable_segtrap = FALSE;
 151
 152 /* control the behaviour of registry rebuild */
 153 static gboolean _gst_enable_registry_fork = DEFAULT_FORK;
 154
 155 static void load_plugin_func (gpointer data, gpointer user_data);
 156 static gboolean init_pre (GOptionContext * context, GOptionGroup * group,
 157     gpointer data, GError ** error);
 158 static gboolean init_post (GOptionContext * context, GOptionGroup * group,
 159     gpointer data, GError ** error);
 160 #ifndef GST_DISABLE_OPTION_PARSING
 161 static gboolean parse_goption_arg (const gchar * s_opt,
 162     const gchar * arg, gpointer data, GError ** err);
 163 #endif
 164
 165 static GSList *preload_plugins = NULL;
 166
 167 const gchar g_log_domain_gstreamer[] = "GStreamer";
 168
 169 static void
 170 debug_log_handler (const gchar * log_domain,
 171     GLogLevelFlags log_level, const gchar * message, gpointer user_data)
 172 {
 173   g_log_default_handler (log_domain, log_level, message, user_data);
 174   /* FIXME: do we still need this ? fatal errors these days are all
 175    * other than core errors */
 176   /* g_on_error_query (NULL); */
 177 }
 178
 179 enum
 180 {
 181   ARG_VERSION = 1,
 182   ARG_FATAL_WARNINGS,
 183 #ifndef GST_DISABLE_GST_DEBUG
 184   ARG_DEBUG_LEVEL,
 185   ARG_DEBUG,
 186   ARG_DEBUG_DISABLE,
 187   ARG_DEBUG_NO_COLOR,
 188   ARG_DEBUG_HELP,
 189 #endif
 190   ARG_PLUGIN_SPEW,
 191   ARG_PLUGIN_PATH,
 192   ARG_PLUGIN_LOAD,
 193   ARG_SEGTRAP_DISABLE,
 194   ARG_REGISTRY_FORK_DISABLE
 195 };
 196
 197 /* debug-spec ::= category-spec [, category-spec]*
 198  * category-spec ::= category:val | val
 199  * category ::= [^:]+
 200  * val ::= [0-5]
 201  */
 202
 203 #ifndef NUL
 204 #define NUL '\0'
 205 #endif
 206
 207 #ifndef GST_DISABLE_GST_DEBUG
 208 static gboolean
 209 parse_debug_category (gchar * str, const gchar ** category)
 210 {
 211   if (!str)
 212     return FALSE;
 213
 214   /* works in place */
 215   g_strstrip (str);
 216
 217   if (str[0] != NUL) {
 218     *category = str;
 219     return TRUE;
 220   }
 221
 222   return FALSE;
 223 }
 224
 225 static gboolean
 226 parse_debug_level (gchar * str, gint * level)
 227 {
 228   if (!str)
 229     return FALSE;
 230
 231   /* works in place */
 232   g_strstrip (str);
 233
 234   if (str[0] != NUL && str[1] == NUL
 235       && str[0] >= '0' && str[0] < '0' + GST_LEVEL_COUNT) {
 236     *level = str[0] - '0';
 237     return TRUE;
 238   }
 239
 240   return FALSE;
 241 }
 242
 243 static void
 244 parse_debug_list (const gchar * list)
 245 {
 246   gchar **split;
 247   gchar **walk;
 248
 249   g_return_if_fail (list != NULL);
 250
 251   split = g_strsplit (list, ",", 0);
 252
 253   for (walk = split; *walk; walk++) {
 254     if (strchr (*walk, ':')) {
 255       gchar **values = g_strsplit (*walk, ":", 2);
 256
 257       if (values[0] && values[1]) {
 258         gint level;
 259         const gchar *category;
 260
 261         if (parse_debug_category (values[0], &category)
 262             && parse_debug_level (values[1], &level))
 263           gst_debug_set_threshold_for_name (category, level);
 264       }
 265
 266       g_strfreev (values);
 267     } else {
 268       gint level;
 269
 270       if (parse_debug_level (*walk, &level))
 271         gst_debug_set_default_threshold (level);
 272     }
 273   }
 274
 275   g_strfreev (split);
 276 }
 277 #endif
 278
 279 /**
 280  * gst_init_get_option_group:
 281  *
 282  * Returns a #GOptionGroup with GStreamer's argument specifications. The
 283  * group is set up to use standard GOption callbacks, so when using this
 284  * group in combination with GOption parsing methods, all argument parsing
 285  * and initialization is automated.
 286  *
 287  * This function is useful if you want to integrate GStreamer with other
 288  * libraries that use GOption (see g_option_context_add_group() ).
 289  *
 290  * If you use this function, you should make sure you initialise the GLib
 291  * threading system as one of the very first things in your program
 292  * (see the example at the beginning of this section).
 293  *
 294  * Returns: a pointer to GStreamer's option group.
 295  */
 296
 297 GOptionGroup *
 298 gst_init_get_option_group (void)
 299 {
 300 #ifndef GST_DISABLE_OPTION_PARSING
 301   GOptionGroup *group;
 302   const static GOptionEntry gst_args[] = {
 303     {"gst-version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 304         (gpointer) parse_goption_arg, N_("Print the GStreamer version"), NULL},
 305     {"gst-fatal-warnings", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 306         (gpointer) parse_goption_arg, N_("Make all warnings fatal"), NULL},
 307 #ifndef GST_DISABLE_GST_DEBUG
 308     {"gst-debug-help", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 309           (gpointer) parse_goption_arg,
 310           N_("Print available debug categories and exit"),
 311         NULL},
 312     {"gst-debug-level", 0, 0, G_OPTION_ARG_CALLBACK,
 313           (gpointer) parse_goption_arg,
 314           N_("Default debug level from 1 (only error) to 5 (anything) or "
 315               "0 for no output"),
 316         N_("LEVEL")},
 317     {"gst-debug", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) parse_goption_arg,
 318           N_("Comma-separated list of category_name:level pairs to set "
 319               "specific levels for the individual categories. Example: "
 320               "GST_AUTOPLUG:5,GST_ELEMENT_*:3"),
 321         N_("LIST")},
 322     {"gst-debug-no-color", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 323           (gpointer) parse_goption_arg, N_("Disable colored debugging output"),
 324         NULL},
 325     {"gst-debug-disable", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 326         (gpointer) parse_goption_arg, N_("Disable debugging"), NULL},
 327 #endif
 328     {"gst-plugin-spew", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 329           (gpointer) parse_goption_arg,
 330           N_("Enable verbose plugin loading diagnostics"),
 331         NULL},
 332     {"gst-plugin-path", 0, 0, G_OPTION_ARG_CALLBACK,
 333           (gpointer) parse_goption_arg,
 334         N_("Colon-separated paths containing plugins"), N_("PATHS")},
 335     {"gst-plugin-load", 0, 0, G_OPTION_ARG_CALLBACK,
 336           (gpointer) parse_goption_arg,
 337           N_("Comma-separated list of plugins to preload in addition to the "
 338               "list stored in environment variable GST_PLUGIN_PATH"),
 339         N_("PLUGINS")},
 340     {"gst-disable-segtrap", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
 341           (gpointer) parse_goption_arg,
 342           N_("Disable trapping of segmentation faults during plugin loading"),
 343         NULL},
 344     {"gst-disable-registry-fork", 0, G_OPTION_FLAG_NO_ARG,
 345           G_OPTION_ARG_CALLBACK,
 346           (gpointer) parse_goption_arg,
 347           N_("Disable the use of fork() while scanning the registry"),
 348         NULL},
 349     {NULL}
 350   };
 351
 352   /* The GLib threading system must be initialised before calling any other
 353    * GLib function according to the documentation; if the application hasn't
 354    * called gst_init() yet or initialised the threading system otherwise, we
 355    * better issue a warning here (since chances are high that the application
 356    * has already called other GLib functions such as g_option_context_new() */
 357   if (!g_thread_supported ()) {
 358     g_warning ("The GStreamer function gst_init_get_option_group() was\n"
 359         "\tcalled, but the GLib threading system has not been initialised\n"
 360         "\tyet, something that must happen before any other GLib function\n"
 361         "\tis called. The application needs to be fixed so that it calls\n"
 362         "\t   if (!g_thread_supported ()) g_thread_init(NULL);\n"
 363         "\tas very first thing in its main() function. Please file a bug\n"
 364         "\tagainst this application.");
 365     g_thread_init (NULL);
 366   }
 367
 368   group = g_option_group_new ("gst", _("GStreamer Options"),
 369       _("Show GStreamer Options"), NULL, NULL);
 370   g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,
 371       (GOptionParseFunc) init_post);
 372
 373   g_option_group_add_entries (group, gst_args);
 374   g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
 375
 376   return group;
 377 #else
 378   return NULL;
 379 #endif
 380 }
 381
 382 /**
 383  * gst_init_check:
 384  * @argc: pointer to application's argc
 385  * @argv: pointer to application's argv
 386  * @err: pointer to a #GError to which a message will be posted on error
 387  *
 388  * Initializes the GStreamer library, setting up internal path lists,
 389  * registering built-in elements, and loading standard plugins.
 390  *
 391  * This function will return %FALSE if GStreamer could not be initialized
 392  * for some reason.  If you want your program to fail fatally,
 393  * use gst_init() instead.
 394  *
 395  * This function should be called before calling any other GLib functions. If
 396  * this is not an option, your program must initialise the GLib thread system
 397  * using g_thread_init() before any other GLib functions are called.
 398  *
 399  * Returns: %TRUE if GStreamer could be initialized.
 400  */
 401 gboolean
 402 gst_init_check (int *argc, char **argv[], GError ** err)
 403 {
 404 #ifndef GST_DISABLE_OPTION_PARSING
 405   GOptionGroup *group;
 406   GOptionContext *ctx;
 407 #endif
 408   gboolean res;
 409
 410   if (!g_thread_supported ())
 411     g_thread_init (NULL);
 412
 413   if (gst_initialized) {
 414     GST_DEBUG ("already initialized gst");
 415     return TRUE;
 416   }
 417 #ifndef GST_DISABLE_OPTION_PARSING
 418   ctx = g_option_context_new ("- GStreamer initialization");
 419   g_option_context_set_ignore_unknown_options (ctx, TRUE);
 420   group = gst_init_get_option_group ();
 421   g_option_context_add_group (ctx, group);
 422   res = g_option_context_parse (ctx, argc, argv, err);
 423   g_option_context_free (ctx);
 424 #else
 425   init_pre (NULL, NULL, NULL, NULL);
 426   init_post (NULL, NULL, NULL, NULL);
 427   res = TRUE;
 428 #endif
 429
 430   gst_initialized = res;
 431
 432   if (res) {
 433     GST_INFO ("initialized GStreamer successfully");
 434   } else {
 435     GST_INFO ("failed to initialize GStreamer");
 436   }
 437
 438   return res;
 439 }
 440
 441 /**
 442  * gst_init:
 443  * @argc: pointer to application's argc
 444  * @argv: pointer to application's argv
 445  *
 446  * Initializes the GStreamer library, setting up internal path lists,
 447  * registering built-in elements, and loading standard plugins.
 448  *
 449  * This function should be called before calling any other GLib functions. If
 450  * this is not an option, your program must initialise the GLib thread system
 451  * using g_thread_init() before any other GLib functions are called.
 452  *
 453  * <note><para>
 454  * This function will terminate your program if it was unable to initialize
 455  * GStreamer for some reason.  If you want your program to fall back,
 456  * use gst_init_check() instead.
 457  * </para></note>
 458  *
 459  * WARNING: This function does not work in the same way as corresponding
 460  * functions in other glib-style libraries, such as gtk_init().  In
 461  * particular, unknown command line options cause this function to
 462  * abort program execution.
 463  */
 464 void
 465 gst_init (int *argc, char **argv[])
 466 {
 467   GError *err = NULL;
 468
 469   if (!gst_init_check (argc, argv, &err)) {
 470     g_print ("Could not initialize GStreamer: %s\n",
 471         err ? err->message : "unknown error occurred");
 472     if (err) {
 473       g_error_free (err);
 474     }
 475     exit (1);
 476   }
 477 }
 478
 479 #ifndef GST_DISABLE_REGISTRY
 480 static void
 481 add_path_func (gpointer data, gpointer user_data)
 482 {
 483   GST_INFO ("Adding plugin path: \"%s\", will scan later", (gchar *) data);
 484   plugin_paths = g_list_append (plugin_paths, g_strdup (data));
 485 }
 486 #endif
 487
 488 #ifndef GST_DISABLE_OPTION_PARSING
 489 static void
 490 prepare_for_load_plugin_func (gpointer data, gpointer user_data)
 491 {
 492   preload_plugins = g_slist_prepend (preload_plugins, g_strdup (data));
 493 }
 494 #endif
 495
 496 static void
 497 load_plugin_func (gpointer data, gpointer user_data)
 498 {
 499   GstPlugin *plugin;
 500   const gchar *filename;
 501   GError *err = NULL;
 502
 503   filename = (const gchar *) data;
 504
 505   plugin = gst_plugin_load_file (filename, &err);
 506
 507   if (plugin) {
 508     GST_INFO ("Loaded plugin: \"%s\"", filename);
 509
 510     gst_default_registry_add_plugin (plugin);
 511   } else {
 512     if (err) {
 513       /* Report error to user, and free error */
 514       GST_ERROR ("Failed to load plugin: %s", err->message);
 515       g_error_free (err);
 516     } else {
 517       GST_WARNING ("Failed to load plugin: \"%s\"", filename);
 518     }
 519   }
 520 }
 521
 522 #ifndef GST_DISABLE_OPTION_PARSING
 523 static void
 524 split_and_iterate (const gchar * stringlist, gchar * separator, GFunc iterator,
 525     gpointer user_data)
 526 {
 527   gchar **strings;
 528   gint j = 0;
 529   gchar *lastlist = g_strdup (stringlist);
 530
 531   while (lastlist) {
 532     strings = g_strsplit (lastlist, separator, MAX_PATH_SPLIT);
 533     g_free (lastlist);
 534     lastlist = NULL;
 535
 536     while (strings[j]) {
 537       iterator (strings[j], user_data);
 538       if (++j == MAX_PATH_SPLIT) {
 539         lastlist = g_strdup (strings[j]);
 540         j = 0;
 541         break;
 542       }
 543     }
 544     g_strfreev (strings);
 545   }
 546 }
 547 #endif
 548
 549 /* we have no fail cases yet, but maybe in the future */
 550 static gboolean
 551 init_pre (GOptionContext * context, GOptionGroup * group, gpointer data,
 552     GError ** error)
 553 {
 554   if (gst_initialized) {
 555     GST_DEBUG ("already initialized");
 556     return TRUE;
 557   }
 558
 559   /* GStreamer was built against a GLib >= 2.8 and is therefore not doing
 560    * the refcount hack. Check that it isn't being run against an older GLib */
 561   if (glib_major_version < 2 ||
 562       (glib_major_version == 2 && glib_minor_version < 8)) {
 563     g_warning ("GStreamer was compiled against GLib %d.%d.%d but is running"
 564         " against %d.%d.%d. This will cause reference counting issues",
 565         GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION,
 566         glib_major_version, glib_minor_version, glib_micro_version);
 567   }
 568
 569   g_type_init ();
 570
 571   /* we need threading to be enabled right here */
 572   g_assert (g_thread_supported ());
 573   _gst_debug_init ();
 574
 575 #ifdef ENABLE_NLS
 576   setlocale (LC_ALL, "");
 577   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
 578 #endif /* ENABLE_NLS */
 579
 580 #ifndef GST_DISABLE_GST_DEBUG
 581   {
 582     const gchar *debug_list;
 583
 584     if (g_getenv ("GST_DEBUG_NO_COLOR") != NULL)
 585       gst_debug_set_colored (FALSE);
 586
 587     debug_list = g_getenv ("GST_DEBUG");
 588     if (debug_list) {
 589       parse_debug_list (debug_list);
 590     }
 591   }
 592
 593   priv_gst_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
 594 #endif
 595   /* This is the earliest we can make stuff show up in the logs.
 596    * So give some useful info about GStreamer here */
 597   GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
 598   GST_INFO ("Using library installed in %s", LIBDIR);
 599
 600   /* Print some basic system details if possible (OS/architecture) */
 601 #ifdef HAVE_SYS_UTSNAME_H
 602   {
 603     struct utsname sys_details;
 604
 605     if (uname (&sys_details) == 0) {
 606       GST_INFO ("%s %s %s %s %s", sys_details.sysname,
 607           sys_details.nodename, sys_details.release, sys_details.version,
 608           sys_details.machine);
 609     }
 610   }
 611 #endif
 612
 613   return TRUE;
 614 }
 615
 616 static gboolean
 617 gst_register_core_elements (GstPlugin * plugin)
 618 {
 619   /* register some standard builtin types */
 620   if (!gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
 621           GST_TYPE_BIN) ||
 622       !gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
 623           GST_TYPE_PIPELINE)
 624       )
 625     g_assert_not_reached ();
 626
 627   return TRUE;
 628 }
 629
 630 static GstPluginDesc plugin_desc = {
 631   GST_VERSION_MAJOR,
 632   GST_VERSION_MINOR,
 633   "staticelements",
 634   "core elements linked into the GStreamer library",
 635   gst_register_core_elements,
 636   VERSION,
 637   GST_LICENSE,
 638   PACKAGE,
 639   GST_PACKAGE_NAME,
 640   GST_PACKAGE_ORIGIN,
 641
 642   GST_PADDING_INIT
 643 };
 644
 645 #ifndef GST_DISABLE_REGISTRY
 646
 647 typedef enum
 648 {
 649   REGISTRY_SCAN_AND_UPDATE_FAILURE = 0,
 650   REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED,
 651   REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED
 652 } GstRegistryScanAndUpdateResult;
 653
 654 /*
 655  * scan_and_update_registry:
 656  * @default_registry: the #GstRegistry
 657  * @registry_file: registry filename
 658  * @write_changes: write registry if it has changed?
 659  *
 660  * Scans for registry changes and eventually updates the registry cache.
 661  *
 662  * Return: %REGISTRY_SCAN_AND_UPDATE_FAILURE if the registry could not scanned
 663  *         or updated, %REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED if the
 664  *         registry is clean and %REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED if
 665  *         it has been updated and the cache needs to be re-read.
 666  */
 667 static GstRegistryScanAndUpdateResult
 668 scan_and_update_registry (GstRegistry * default_registry,
 669     const gchar * registry_file, gboolean write_changes, GError ** error)
 670 {
 671   const gchar *plugin_path;
 672   gboolean changed = FALSE;
 673   GList *l;
 674
 675   /* scan paths specified via --gst-plugin-path */
 676   GST_DEBUG ("scanning paths added via --gst-plugin-path");
 677   for (l = plugin_paths; l != NULL; l = l->next) {
 678     GST_INFO ("Scanning plugin path: \"%s\"", (gchar *) l->data);
 679     /* CHECKME: add changed |= here as well? */
 680     gst_registry_scan_path (default_registry, (gchar *) l->data);
 681   }
 682   /* keep plugin_paths around in case a re-scan is forced later on */
 683
 684   /* GST_PLUGIN_PATH specifies a list of directories to scan for
 685    * additional plugins.  These take precedence over the system plugins */
 686   plugin_path = g_getenv ("GST_PLUGIN_PATH");
 687   if (plugin_path) {
 688     char **list;
 689     int i;
 690
 691     GST_DEBUG ("GST_PLUGIN_PATH set to %s", plugin_path);
 692     list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
 693     for (i = 0; list[i]; i++) {
 694       changed |= gst_registry_scan_path (default_registry, list[i]);
 695     }
 696     g_strfreev (list);
 697   } else {
 698     GST_DEBUG ("GST_PLUGIN_PATH not set");
 699   }
 700
 701   /* GST_PLUGIN_SYSTEM_PATH specifies a list of plugins that are always
 702    * loaded by default.  If not set, this defaults to the system-installed
 703    * path, and the plugins installed in the user's home directory */
 704   plugin_path = g_getenv ("GST_PLUGIN_SYSTEM_PATH");
 705   if (plugin_path == NULL) {
 706     char *home_plugins;
 707
 708     GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH not set");
 709
 710     /* plugins in the user's home directory take precedence over
 711      * system-installed ones */
 712     home_plugins = g_build_filename (g_get_home_dir (),
 713         ".gstreamer-" GST_MAJORMINOR, "plugins", NULL);
 714     GST_DEBUG ("scanning home plugins %s", home_plugins);
 715     changed |= gst_registry_scan_path (default_registry, home_plugins);
 716     g_free (home_plugins);
 717
 718     /* add the main (installed) library path */
 719     GST_DEBUG ("scanning main plugins %s", PLUGINDIR);
 720     changed |= gst_registry_scan_path (default_registry, PLUGINDIR);
 721   } else {
 722     gchar **list;
 723     gint i;
 724
 725     GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH set to %s", plugin_path);
 726     list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
 727     for (i = 0; list[i]; i++) {
 728       changed |= gst_registry_scan_path (default_registry, list[i]);
 729     }
 730     g_strfreev (list);
 731   }
 732
 733   /* Remove cached plugins so stale info is cleared. */
 734   changed |= _priv_gst_registry_remove_cache_plugins (default_registry);
 735
 736   if (!changed) {
 737     GST_INFO ("Registry cache has not changed");
 738     return REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED;
 739   }
 740
 741   if (!write_changes) {
 742     GST_INFO ("Registry cached changed, but writing is disabled. Not writing.");
 743     return REGISTRY_SCAN_AND_UPDATE_FAILURE;
 744   }
 745
 746   GST_INFO ("Registry cache changed. Writing new registry cache");
 747 #ifdef USE_BINARY_REGISTRY
 748   if (!gst_registry_binary_write_cache (default_registry, registry_file)) {
 749 #else
 750   if (!gst_registry_xml_write_cache (default_registry, registry_file)) {
 751 #endif
 752     g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 753         _("Error writing registry cache to %s: %s"),
 754         registry_file, g_strerror (errno));
 755     return REGISTRY_SCAN_AND_UPDATE_FAILURE;
 756   }
 757
 758   GST_INFO ("Registry cache written successfully");
 759   return REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED;
 760 }
 761
 762 static gboolean
 763 ensure_current_registry_nonforking (GstRegistry * default_registry,
 764     const gchar * registry_file, GError ** error)
 765 {
 766   /* fork() not available */
 767   GST_INFO ("reading registry cache: %s", registry_file);
 768 #ifdef USE_BINARY_REGISTRY
 769   gst_registry_binary_read_cache (default_registry, registry_file);
 770 #else
 771   gst_registry_xml_read_cache (default_registry, registry_file);
 772 #endif
 773   GST_DEBUG ("Updating registry cache in-process");
 774   scan_and_update_registry (default_registry, registry_file, TRUE, error);
 775   return TRUE;
 776 }
 777
 778 /* when forking is not available this function always does nothing but return
 779  * TRUE immediatly */
 780 static gboolean
 781 ensure_current_registry_forking (GstRegistry * default_registry,
 782     const gchar * registry_file, GError ** error)
 783 {
 784 #ifdef HAVE_FORK
 785   pid_t pid;
 786   int pfd[2];
 787   int ret;
 788
 789   /* We fork here, and let the child read and possibly rebuild the registry.
 790    * After that, the parent will re-read the freshly generated registry. */
 791   GST_DEBUG ("forking to update registry");
 792
 793   if (pipe (pfd) == -1) {
 794     g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 795         _("Error re-scanning registry %s: %s"),
 796         ", could not create pipes. Error", g_strerror (errno));
 797     return FALSE;
 798   }
 799
 800   GST_INFO ("reading registry cache: %s", registry_file);
 801 #ifdef USE_BINARY_REGISTRY
 802   gst_registry_binary_read_cache (default_registry, registry_file);
 803 #else
 804   gst_registry_xml_read_cache (default_registry, registry_file);
 805 #endif
 806
 807   pid = fork ();
 808   if (pid == -1) {
 809     GST_ERROR ("Failed to fork()");
 810     g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 811         _("Error re-scanning registry %s: %s"),
 812         ", failed to fork. Error", g_strerror (errno));
 813     return FALSE;
 814   }
 815
 816   if (pid == 0) {
 817     gint result_code;
 818
 819     /* this is the child. Close the read pipe */
 820     (void) close (pfd[0]);
 821
 822     GST_DEBUG ("child reading registry cache");
 823     result_code =
 824         scan_and_update_registry (default_registry, registry_file, TRUE, NULL);
 825
 826     /* need to use _exit, so that any exit handlers registered don't
 827      * bring down the main program */
 828     GST_DEBUG ("child exiting: %d", result_code);
 829
 830     /* make valgrind happy (yes, you can call it insane) */
 831     g_free ((char *) registry_file);
 832
 833     /* write a result byte to the pipe */
 834     do {
 835       ret = write (pfd[1], &result_code, sizeof (result_code));
 836     } while (ret == -1 && errno == EINTR);
 837     /* if ret == -1 now, we could not write to pipe, probably
 838      * means parent has exited before us */
 839     (void) close (pfd[1]);
 840
 841     _exit (0);
 842   } else {
 843     gint result_code;
 844
 845     /* parent. Close write pipe */
 846     (void) close (pfd[1]);
 847
 848     /* Wait for result from the pipe */
 849     GST_DEBUG ("Waiting for data from child");
 850     do {
 851       ret = read (pfd[0], &result_code, sizeof (result_code));
 852     } while (ret == -1 && errno == EINTR);
 853
 854     if (ret == -1) {
 855       g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 856           _("Error re-scanning registry %s: %s"),
 857           ", read returned error", g_strerror (errno));
 858       close (pfd[0]);
 859       return FALSE;
 860     }
 861     (void) close (pfd[0]);
 862
 863     /* Wait to ensure the child is reaped, but ignore the result */
 864     GST_DEBUG ("parent waiting on child");
 865     waitpid (pid, NULL, 0);
 866     GST_DEBUG ("parent done waiting on child");
 867
 868     if (ret == 0) {
 869       GST_ERROR ("child did not exit normally, terminated by signal");
 870       g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 871           _("Error re-scanning registry %s"), ", child terminated by signal");
 872       return FALSE;
 873     }
 874
 875     if (result_code == REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED) {
 876       GST_DEBUG ("Child succeeded. Parent reading registry cache");
 877       _priv_gst_registry_remove_cache_plugins (default_registry);
 878 #ifdef USE_BINARY_REGISTRY
 879       gst_registry_binary_read_cache (default_registry, registry_file);
 880 #else
 881       gst_registry_xml_read_cache (default_registry, registry_file);
 882 #endif
 883     } else if (result_code == REGISTRY_SCAN_AND_UPDATE_FAILURE) {
 884       GST_DEBUG ("Child failed. Parent re-scanning registry, ignoring errors.");
 885       scan_and_update_registry (default_registry, registry_file, FALSE, NULL);
 886     }
 887   }
 888 #endif /* HAVE_FORK */
 889   return TRUE;
 890 }
 891
 892 static gboolean
 893 ensure_current_registry (GError ** error)
 894 {
 895   char *registry_file;
 896   GstRegistry *default_registry;
 897   gboolean ret;
 898   gboolean do_fork;
 899
 900   default_registry = gst_registry_get_default ();
 901   registry_file = g_strdup (g_getenv ("GST_REGISTRY"));
 902   if (registry_file == NULL) {
 903 #ifdef USE_BINARY_REGISTRY
 904     registry_file = g_build_filename (g_get_home_dir (),
 905         ".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".bin", NULL);
 906 #else
 907     registry_file = g_build_filename (g_get_home_dir (),
 908         ".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".xml", NULL);
 909 #endif
 910   }
 911
 912   /* first see if forking is enabled */
 913   do_fork = _gst_enable_registry_fork;
 914   if (do_fork) {
 915     const gchar *fork_env;
 916
 917     /* forking enabled, see if it is disabled with an env var */
 918     if ((fork_env = g_getenv ("GST_REGISTRY_FORK"))) {
 919       /* fork enabled for any value different from "no" */
 920       do_fork = strcmp (fork_env, "no") != 0;
 921     }
 922   }
 923
 924   /* now check registry with or without forking */
 925   if (do_fork) {
 926     GST_DEBUG ("forking for registry rebuild");
 927     ret = ensure_current_registry_forking (default_registry, registry_file,
 928         error);
 929   } else {
 930     GST_DEBUG ("requested not to fork for registry rebuild");
 931     ret = ensure_current_registry_nonforking (default_registry, registry_file,
 932         error);
 933   }
 934
 935   g_free (registry_file);
 936
 937   return ret;
 938 }
 939 #endif /* GST_DISABLE_REGISTRY */
 940
 941 /*
 942  * this bit handles:
 943  * - initalization of threads if we use them
 944  * - log handler
 945  * - initial output
 946  * - initializes gst_format
 947  * - registers a bunch of types for gst_objects
 948  *
 949  * - we don't have cases yet where this fails, but in the future
 950  *   we might and then it's nice to be able to return that
 951  */
 952 static gboolean
 953 init_post (GOptionContext * context, GOptionGroup * group, gpointer data,
 954     GError ** error)
 955 {
 956   GLogLevelFlags llf;
 957
 958 #ifndef GST_DISABLE_TRACE
 959   GstTrace *gst_trace;
 960 #endif /* GST_DISABLE_TRACE */
 961
 962   if (gst_initialized) {
 963     GST_DEBUG ("already initialized");
 964     return TRUE;
 965   }
 966
 967   llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
 968   g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
 969
 970   _priv_gst_quarks_initialize ();
 971   _gst_format_initialize ();
 972   _gst_query_initialize ();
 973   g_type_class_ref (gst_object_get_type ());
 974   g_type_class_ref (gst_pad_get_type ());
 975   g_type_class_ref (gst_element_factory_get_type ());
 976   g_type_class_ref (gst_element_get_type ());
 977   g_type_class_ref (gst_type_find_factory_get_type ());
 978   g_type_class_ref (gst_bin_get_type ());
 979
 980 #ifndef GST_DISABLE_INDEX
 981   g_type_class_ref (gst_index_factory_get_type ());
 982 #endif /* GST_DISABLE_INDEX */
 983 #ifndef GST_DISABLE_URI
 984   gst_uri_handler_get_type ();
 985 #endif /* GST_DISABLE_URI */
 986
 987   gst_structure_get_type ();
 988   _gst_value_initialize ();
 989   g_type_class_ref (gst_param_spec_fraction_get_type ());
 990   gst_caps_get_type ();
 991   _gst_event_initialize ();
 992   _gst_buffer_initialize ();
 993   _gst_message_initialize ();
 994   _gst_tag_initialize ();
 995
 996   /* register core plugins */
 997   _gst_plugin_register_static (&plugin_desc);
 998
 999   _gst_plugin_initialize ();
1000
1001   /*
1002    * Any errors happening below this point are non-fatal, we therefore mark
1003    * gstreamer as being initialized, since it is the case from a plugin point of
1004    * view.
1005    *
1006    * If anything fails, it will be put back to FALSE in gst_init_check().
1007    * This allows some special plugins that would call gst_init() to not cause a
1008    * looping effect (i.e. initializing GStreamer twice).
1009    */
1010   gst_initialized = TRUE;
1011
1012 #ifndef GST_DISABLE_REGISTRY
1013   if (!ensure_current_registry (error))
1014     return FALSE;
1015 #endif /* GST_DISABLE_REGISTRY */
1016
1017   /* if we need to preload plugins, do so now */
1018   g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1019   /* keep preload_plugins around in case a re-scan is forced later on */
1020
1021 #ifndef GST_DISABLE_TRACE
1022   _gst_trace_on = 0;
1023   if (_gst_trace_on) {
1024     gst_trace = gst_trace_new ("gst.trace", 1024);
1025     gst_trace_set_default (gst_trace);
1026   }
1027 #endif /* GST_DISABLE_TRACE */
1028
1029   return TRUE;
1030 }
1031
1032 #ifndef GST_DISABLE_GST_DEBUG
1033 static gboolean
1034 select_all (GstPlugin * plugin, gpointer user_data)
1035 {
1036   return TRUE;
1037 }
1038
1039 static gint
1040 sort_by_category_name (gconstpointer a, gconstpointer b)
1041 {
1042   return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
1043       gst_debug_category_get_name ((GstDebugCategory *) b));
1044 }
1045
1046 static void
1047 gst_debug_help (void)
1048 {
1049   GSList *list, *walk;
1050   GList *list2, *g;
1051
1052   /* Need to ensure the registry is loaded to get debug categories */
1053   if (!init_post (NULL, NULL, NULL, NULL))
1054     exit (1);
1055
1056   list2 = gst_registry_plugin_filter (gst_registry_get_default (),
1057       select_all, FALSE, NULL);
1058
1059   /* FIXME this is gross.  why don't debug have categories PluginFeatures? */
1060   for (g = list2; g; g = g_list_next (g)) {
1061     GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
1062
1063     gst_plugin_load (plugin);
1064   }
1065   g_list_free (list2);
1066
1067   list = gst_debug_get_all_categories ();
1068   walk = list = g_slist_sort (list, sort_by_category_name);
1069
1070   g_print ("\n");
1071   g_print ("name                  level    description\n");
1072   g_print ("---------------------+--------+--------------------------------\n");
1073
1074   while (walk) {
1075     GstDebugCategory *cat = (GstDebugCategory *) walk->data;
1076
1077     if (gst_debug_is_colored ()) {
1078       gchar *color = gst_debug_construct_term_color (cat->color);
1079
1080       g_print ("%s%-20s\033[00m  %1d %s  %s%s\033[00m\n",
1081           color,
1082           gst_debug_category_get_name (cat),
1083           gst_debug_category_get_threshold (cat),
1084           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1085           color, gst_debug_category_get_description (cat));
1086       g_free (color);
1087     } else {
1088       g_print ("%-20s  %1d %s  %s\n", gst_debug_category_get_name (cat),
1089           gst_debug_category_get_threshold (cat),
1090           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1091           gst_debug_category_get_description (cat));
1092     }
1093     walk = g_slist_next (walk);
1094   }
1095   g_slist_free (list);
1096   g_print ("\n");
1097 }
1098 #endif
1099
1100 #ifndef GST_DISABLE_OPTION_PARSING
1101 static gboolean
1102 parse_one_option (gint opt, const gchar * arg, GError ** err)
1103 {
1104   switch (opt) {
1105     case ARG_VERSION:
1106       g_print ("GStreamer Core Library version %s\n", PACKAGE_VERSION);
1107       exit (0);
1108     case ARG_FATAL_WARNINGS:{
1109       GLogLevelFlags fatal_mask;
1110
1111       fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
1112       fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
1113       g_log_set_always_fatal (fatal_mask);
1114       break;
1115     }
1116 #ifndef GST_DISABLE_GST_DEBUG
1117     case ARG_DEBUG_LEVEL:{
1118       gint tmp = 0;
1119
1120       tmp = strtol (arg, NULL, 0);
1121       if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
1122         gst_debug_set_default_threshold (tmp);
1123       }
1124       break;
1125     }
1126     case ARG_DEBUG:
1127       parse_debug_list (arg);
1128       break;
1129     case ARG_DEBUG_NO_COLOR:
1130       gst_debug_set_colored (FALSE);
1131       break;
1132     case ARG_DEBUG_DISABLE:
1133       gst_debug_set_active (FALSE);
1134       break;
1135     case ARG_DEBUG_HELP:
1136       gst_debug_help ();
1137       exit (0);
1138 #endif
1139     case ARG_PLUGIN_SPEW:
1140       break;
1141     case ARG_PLUGIN_PATH:
1142 #ifndef GST_DISABLE_REGISTRY
1143       split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func, NULL);
1144 #endif /* GST_DISABLE_REGISTRY */
1145       break;
1146     case ARG_PLUGIN_LOAD:
1147       split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
1148       break;
1149     case ARG_SEGTRAP_DISABLE:
1150       _gst_disable_segtrap = TRUE;
1151       break;
1152     case ARG_REGISTRY_FORK_DISABLE:
1153       _gst_enable_registry_fork = FALSE;
1154       break;
1155     default:
1156       g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
1157           _("Unknown option"));
1158       return FALSE;
1159   }
1160
1161   return TRUE;
1162 }
1163
1164 static gboolean
1165 parse_goption_arg (const gchar * opt,
1166     const gchar * arg, gpointer data, GError ** err)
1167 {
1168   static const struct
1169   {
1170     gchar *opt;
1171     int val;
1172   } options[] = {
1173     {
1174     "--gst-version", ARG_VERSION}, {
1175     "--gst-fatal-warnings", ARG_FATAL_WARNINGS},
1176 #ifndef GST_DISABLE_GST_DEBUG
1177     {
1178     "--gst-debug-level", ARG_DEBUG_LEVEL}, {
1179     "--gst-debug", ARG_DEBUG}, {
1180     "--gst-debug-disable", ARG_DEBUG_DISABLE}, {
1181     "--gst-debug-no-color", ARG_DEBUG_NO_COLOR}, {
1182     "--gst-debug-help", ARG_DEBUG_HELP},
1183 #endif
1184     {
1185     "--gst-plugin-spew", ARG_PLUGIN_SPEW}, {
1186     "--gst-plugin-path", ARG_PLUGIN_PATH}, {
1187     "--gst-plugin-load", ARG_PLUGIN_LOAD}, {
1188     "--gst-disable-segtrap", ARG_SEGTRAP_DISABLE}, {
1189     "--gst-disable-registry-fork", ARG_REGISTRY_FORK_DISABLE}, {
1190     NULL}
1191   };
1192   gint val = 0, n;
1193
1194   for (n = 0; options[n].opt; n++) {
1195     if (!strcmp (opt, options[n].opt)) {
1196       val = options[n].val;
1197       break;
1198     }
1199   }
1200
1201   return parse_one_option (val, arg, err);
1202 }
1203 #endif
1204
1205 extern GstRegistry *_gst_registry_default;
1206
1207 /**
1208  * gst_deinit:
1209  *
1210  * Clean up any resources created by GStreamer in gst_init().
1211  *
1212  * It is normally not needed to call this function in a normal application
1213  * as the resources will automatically be freed when the program terminates.
1214  * This function is therefore mostly used by testsuites and other memory
1215  * profiling tools.
1216  *
1217  * After this call GStreamer (including this method) should not be used anymore.
1218  */
1219 void
1220 gst_deinit (void)
1221 {
1222   GstClock *clock;
1223
1224   GST_INFO ("deinitializing GStreamer");
1225
1226   if (!gst_initialized) {
1227     GST_DEBUG ("already deinitialized");
1228     return;
1229   }
1230
1231   g_slist_foreach (preload_plugins, (GFunc) g_free, NULL);
1232   g_slist_free (preload_plugins);
1233   preload_plugins = NULL;
1234
1235 #ifndef GST_DISABLE_REGISTRY
1236   g_list_foreach (plugin_paths, (GFunc) g_free, NULL);
1237   g_list_free (plugin_paths);
1238   plugin_paths = NULL;
1239 #endif
1240
1241   clock = gst_system_clock_obtain ();
1242   gst_object_unref (clock);
1243   gst_object_unref (clock);
1244
1245   _priv_gst_registry_cleanup ();
1246
1247   g_type_class_unref (g_type_class_peek (gst_object_get_type ()));
1248   g_type_class_unref (g_type_class_peek (gst_pad_get_type ()));
1249   g_type_class_unref (g_type_class_peek (gst_element_factory_get_type ()));
1250   g_type_class_unref (g_type_class_peek (gst_element_get_type ()));
1251   g_type_class_unref (g_type_class_peek (gst_type_find_factory_get_type ()));
1252   g_type_class_unref (g_type_class_peek (gst_bin_get_type ()));
1253 #ifndef GST_DISABLE_INDEX
1254   g_type_class_unref (g_type_class_peek (gst_index_factory_get_type ()));
1255 #endif /* GST_DISABLE_INDEX */
1256   g_type_class_unref (g_type_class_peek (gst_param_spec_fraction_get_type ()));
1257
1258   gst_initialized = FALSE;
1259   GST_INFO ("deinitialized GStreamer");
1260 }
1261
1262 /**
1263  * gst_version:
1264  * @major: pointer to a guint to store the major version number
1265  * @minor: pointer to a guint to store the minor version number
1266  * @micro: pointer to a guint to store the micro version number
1267  * @nano:  pointer to a guint to store the nano version number
1268  *
1269  * Gets the version number of the GStreamer library.
1270  */
1271 void
1272 gst_version (guint * major, guint * minor, guint * micro, guint * nano)
1273 {
1274   g_return_if_fail (major);
1275   g_return_if_fail (minor);
1276   g_return_if_fail (micro);
1277   g_return_if_fail (nano);
1278
1279   *major = GST_VERSION_MAJOR;
1280   *minor = GST_VERSION_MINOR;
1281   *micro = GST_VERSION_MICRO;
1282   *nano = GST_VERSION_NANO;
1283 }
1284
1285 /**
1286  * gst_version_string:
1287  *
1288  * This function returns a string that is useful for describing this version
1289  * of GStreamer to the outside world: user agent strings, logging, ...
1290  *
1291  * Returns: a newly allocated string describing this version of GStreamer.
1292  */
1293
1294 gchar *
1295 gst_version_string ()
1296 {
1297   guint major, minor, micro, nano;
1298
1299   gst_version (&major, &minor, &micro, &nano);
1300   if (nano == 0)
1301     return g_strdup_printf ("GStreamer %d.%d.%d", major, minor, micro);
1302   else if (nano == 1)
1303     return g_strdup_printf ("GStreamer %d.%d.%d (CVS)", major, minor, micro);
1304   else
1305     return g_strdup_printf ("GStreamer %d.%d.%d (prerelease)", major, minor,
1306         micro);
1307 }
1308
1309 /**
1310  * gst_segtrap_is_enabled:
1311  *
1312  * Some functions in the GStreamer core might install a custom SIGSEGV handler
1313  * to better catch and report errors to the application. Currently this feature
1314  * is enabled by default when loading plugins.
1315  *
1316  * Applications might want to disable this behaviour with the
1317  * gst_segtrap_set_enabled() function. This is typically done if the application
1318  * wants to install its own handler without GStreamer interfering.
1319  *
1320  * Returns: %TRUE if GStreamer is allowed to install a custom SIGSEGV handler.
1321  *
1322  * Since: 0.10.10
1323  */
1324 gboolean
1325 gst_segtrap_is_enabled (void)
1326 {
1327   /* yeps, it's enabled when it's not disabled */
1328   return !_gst_disable_segtrap;
1329 }
1330
1331 /**
1332  * gst_segtrap_set_enabled:
1333  * @enabled: whether a custom SIGSEGV handler should be installed.
1334  *
1335  * Applications might want to disable/enable the SIGSEGV handling of
1336  * the GStreamer core. See gst_segtrap_is_enabled() for more information.
1337  *
1338  * Since: 0.10.10
1339  */
1340 void
1341 gst_segtrap_set_enabled (gboolean enabled)
1342 {
1343   _gst_disable_segtrap = !enabled;
1344 }
1345
1346 /**
1347  * gst_registry_fork_is_enabled:
1348  *
1349  * By default GStreamer will perform a fork() when scanning and rebuilding the
1350  * registry file.
1351  *
1352  * Applications might want to disable this behaviour with the
1353  * gst_registry_fork_set_enabled() function.
1354  *
1355  * Returns: %TRUE if GStreamer will use fork() when rebuilding the registry. On
1356  * platforms without fork(), this function will always return %FALSE.
1357  *
1358  * Since: 0.10.10
1359  */
1360 gboolean
1361 gst_registry_fork_is_enabled (void)
1362 {
1363   return _gst_enable_registry_fork;
1364 }
1365
1366 /**
1367  * gst_registry_fork_set_enabled:
1368  * @enabled: whether rebuilding the registry may fork
1369  *
1370  * Applications might want to disable/enable the usage of fork() when rebuilding
1371  * the registry. See gst_registry_fork_is_enabled() for more information.
1372  *
1373  * On platforms without fork(), this function will have no effect on the return
1374  * value of gst_registry_fork_is_enabled().
1375  *
1376  * Since: 0.10.10
1377  */
1378 void
1379 gst_registry_fork_set_enabled (gboolean enabled)
1380 {
1381 #ifdef HAVE_FORK
1382   _gst_enable_registry_fork = enabled;
1383 #endif /* HAVE_FORK */
1384 }
1385
1386
1387 /**
1388  * gst_update_registry:
1389  *
1390  * Forces GStreamer to re-scan its plugin paths and update the default
1391  * plugin registry.
1392  *
1393  * Applications will almost never need to call this function, it is only
1394  * useful if the application knows new plugins have been installed (or old
1395  * ones removed) since the start of the application (or, to be precise, the
1396  * first call to gst_init()) and the application wants to make use of any
1397  * newly-installed plugins without restarting the application.
1398  *
1399  * Applications should assume that the registry update is neither atomic nor
1400  * thread-safe and should therefore not have any dynamic pipelines running
1401  * (including the playbin and decodebin elements) and should also not create
1402  * any elements or access the GStreamer registry while the update is in
1403  * progress.
1404  *
1405  * Note that this function may block for a significant amount of time.
1406  *
1407  * Returns: %TRUE if the registry has been updated successfully (does not
1408  *          imply that there were changes), otherwise %FALSE.
1409  *
1410  * Since: 0.10.12
1411  */
1412 gboolean
1413 gst_update_registry (void)
1414 {
1415   gboolean res = FALSE;
1416
1417 #ifndef GST_DISABLE_REGISTRY
1418   GError *err = NULL;
1419
1420   res = ensure_current_registry (&err);
1421   if (err) {
1422     GST_WARNING ("registry update failed: %s", err->message);
1423     g_error_free (err);
1424   } else {
1425     GST_LOG ("registry update succeeded");
1426   }
1427
1428   if (preload_plugins) {
1429     g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1430   }
1431 #else
1432   GST_WARNING ("registry update failed: %s", "registry disabled");
1433 #endif /* GST_DISABLE_REGISTRY */
1434
1435   return res;
1436 }