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