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