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