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 extern const gchar *_gst_debug_dump_dot_dir;
 138
 139 /* defaults */
 140 #ifdef HAVE_FORK
 141 #define DEFAULT_FORK TRUE
 142 #else
 143 #define DEFAULT_FORK FALSE
 144 #endif /* HAVE_FORK */
 145
 146 /* set to TRUE when segfaults need to be left as is, FIXME, this variable is
 147  * global. */
 148 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     _gst_debug_dump_dot_dir = g_getenv ("GST_DEBUG_DUMP_DOT_DIR");
 591   }
 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 static GstPluginDesc plugin_desc = {
 629   GST_VERSION_MAJOR,
 630   GST_VERSION_MINOR,
 631   "staticelements",
 632   "core elements linked into the GStreamer library",
 633   gst_register_core_elements,
 634   VERSION,
 635   GST_LICENSE,
 636   PACKAGE,
 637   GST_PACKAGE_NAME,
 638   GST_PACKAGE_ORIGIN,
 639
 640   GST_PADDING_INIT
 641 };
 642
 643 #ifndef GST_DISABLE_REGISTRY
 644
 645 typedef enum
 646 {
 647   REGISTRY_SCAN_AND_UPDATE_FAILURE = 0,
 648   REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED,
 649   REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED
 650 } GstRegistryScanAndUpdateResult;
 651
 652 /*
 653  * scan_and_update_registry:
 654  * @default_registry: the #GstRegistry
 655  * @registry_file: registry filename
 656  * @write_changes: write registry if it has changed?
 657  *
 658  * Scans for registry changes and eventually updates the registry cache.
 659  *
 660  * Return: %REGISTRY_SCAN_AND_UPDATE_FAILURE if the registry could not scanned
 661  *         or updated, %REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED if the
 662  *         registry is clean and %REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED if
 663  *         it has been updated and the cache needs to be re-read.
 664  */
 665 static GstRegistryScanAndUpdateResult
 666 scan_and_update_registry (GstRegistry * default_registry,
 667     const gchar * registry_file, gboolean write_changes, GError ** error)
 668 {
 669   const gchar *plugin_path;
 670   gboolean changed = FALSE;
 671   GList *l;
 672
 673   /* scan paths specified via --gst-plugin-path */
 674   GST_DEBUG ("scanning paths added via --gst-plugin-path");
 675   for (l = plugin_paths; l != NULL; l = l->next) {
 676     GST_INFO ("Scanning plugin path: \"%s\"", (gchar *) l->data);
 677     /* CHECKME: add changed |= here as well? */
 678     gst_registry_scan_path (default_registry, (gchar *) l->data);
 679   }
 680   /* keep plugin_paths around in case a re-scan is forced later on */
 681
 682   /* GST_PLUGIN_PATH specifies a list of directories to scan for
 683    * additional plugins.  These take precedence over the system plugins */
 684   plugin_path = g_getenv ("GST_PLUGIN_PATH");
 685   if (plugin_path) {
 686     char **list;
 687     int i;
 688
 689     GST_DEBUG ("GST_PLUGIN_PATH set to %s", plugin_path);
 690     list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
 691     for (i = 0; list[i]; i++) {
 692       changed |= gst_registry_scan_path (default_registry, list[i]);
 693     }
 694     g_strfreev (list);
 695   } else {
 696     GST_DEBUG ("GST_PLUGIN_PATH not set");
 697   }
 698
 699   /* GST_PLUGIN_SYSTEM_PATH specifies a list of plugins that are always
 700    * loaded by default.  If not set, this defaults to the system-installed
 701    * path, and the plugins installed in the user's home directory */
 702   plugin_path = g_getenv ("GST_PLUGIN_SYSTEM_PATH");
 703   if (plugin_path == NULL) {
 704     char *home_plugins;
 705
 706     GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH not set");
 707
 708     /* plugins in the user's home directory take precedence over
 709      * system-installed ones */
 710     home_plugins = g_build_filename (g_get_home_dir (),
 711         ".gstreamer-" GST_MAJORMINOR, "plugins", NULL);
 712     GST_DEBUG ("scanning home plugins %s", home_plugins);
 713     changed |= gst_registry_scan_path (default_registry, home_plugins);
 714     g_free (home_plugins);
 715
 716     /* add the main (installed) library path */
 717     GST_DEBUG ("scanning main plugins %s", PLUGINDIR);
 718     changed |= gst_registry_scan_path (default_registry, PLUGINDIR);
 719   } else {
 720     gchar **list;
 721     gint i;
 722
 723     GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH set to %s", plugin_path);
 724     list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
 725     for (i = 0; list[i]; i++) {
 726       changed |= gst_registry_scan_path (default_registry, list[i]);
 727     }
 728     g_strfreev (list);
 729   }
 730
 731   /* Remove cached plugins so stale info is cleared. */
 732   changed |= _priv_gst_registry_remove_cache_plugins (default_registry);
 733
 734   if (!changed) {
 735     GST_INFO ("Registry cache has not changed");
 736     return REGISTRY_SCAN_AND_UPDATE_SUCCESS_NOT_CHANGED;
 737   }
 738
 739   if (!write_changes) {
 740     GST_INFO ("Registry cached changed, but writing is disabled. Not writing.");
 741     return REGISTRY_SCAN_AND_UPDATE_FAILURE;
 742   }
 743
 744   GST_INFO ("Registry cache changed. Writing new registry cache");
 745 #ifdef USE_BINARY_REGISTRY
 746   if (!gst_registry_binary_write_cache (default_registry, registry_file)) {
 747 #else
 748   if (!gst_registry_xml_write_cache (default_registry, registry_file)) {
 749 #endif
 750     g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 751         _("Error writing registry cache to %s: %s"),
 752         registry_file, g_strerror (errno));
 753     return REGISTRY_SCAN_AND_UPDATE_FAILURE;
 754   }
 755
 756   GST_INFO ("Registry cache written successfully");
 757   return REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED;
 758 }
 759
 760 static gboolean
 761 ensure_current_registry_nonforking (GstRegistry * default_registry,
 762     const gchar * registry_file, GError ** error)
 763 {
 764   /* fork() not available */
 765   GST_INFO ("reading registry cache: %s", registry_file);
 766 #ifdef USE_BINARY_REGISTRY
 767   gst_registry_binary_read_cache (default_registry, registry_file);
 768 #else
 769   gst_registry_xml_read_cache (default_registry, registry_file);
 770 #endif
 771   GST_DEBUG ("Updating registry cache in-process");
 772   scan_and_update_registry (default_registry, registry_file, TRUE, error);
 773   return TRUE;
 774 }
 775
 776 /* when forking is not available this function always does nothing but return
 777  * TRUE immediatly */
 778 static gboolean
 779 ensure_current_registry_forking (GstRegistry * default_registry,
 780     const gchar * registry_file, GError ** error)
 781 {
 782 #ifdef HAVE_FORK
 783   pid_t pid;
 784   int pfd[2];
 785   int ret;
 786
 787   /* We fork here, and let the child read and possibly rebuild the registry.
 788    * After that, the parent will re-read the freshly generated registry. */
 789   GST_DEBUG ("forking to update registry");
 790
 791   if (pipe (pfd) == -1) {
 792     g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 793         _("Error re-scanning registry %s: %s"),
 794         ", could not create pipes. Error", g_strerror (errno));
 795     return FALSE;
 796   }
 797
 798   GST_INFO ("reading registry cache: %s", registry_file);
 799 #ifdef USE_BINARY_REGISTRY
 800   gst_registry_binary_read_cache (default_registry, registry_file);
 801 #else
 802   gst_registry_xml_read_cache (default_registry, registry_file);
 803 #endif
 804
 805   pid = fork ();
 806   if (pid == -1) {
 807     GST_ERROR ("Failed to fork()");
 808     g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 809         _("Error re-scanning registry %s: %s"),
 810         ", failed to fork. Error", g_strerror (errno));
 811     return FALSE;
 812   }
 813
 814   if (pid == 0) {
 815     gint result_code;
 816
 817     /* this is the child. Close the read pipe */
 818     (void) close (pfd[0]);
 819
 820     GST_DEBUG ("child reading registry cache");
 821     result_code =
 822         scan_and_update_registry (default_registry, registry_file, TRUE, NULL);
 823
 824     /* need to use _exit, so that any exit handlers registered don't
 825      * bring down the main program */
 826     GST_DEBUG ("child exiting: %d", result_code);
 827
 828     /* make valgrind happy (yes, you can call it insane) */
 829     g_free ((char *) registry_file);
 830
 831     /* write a result byte to the pipe */
 832     do {
 833       ret = write (pfd[1], &result_code, sizeof (result_code));
 834     } while (ret == -1 && errno == EINTR);
 835     /* if ret == -1 now, we could not write to pipe, probably
 836      * means parent has exited before us */
 837     (void) close (pfd[1]);
 838
 839     _exit (0);
 840   } else {
 841     gint result_code;
 842
 843     /* parent. Close write pipe */
 844     (void) close (pfd[1]);
 845
 846     /* Wait for result from the pipe */
 847     GST_DEBUG ("Waiting for data from child");
 848     do {
 849       ret = read (pfd[0], &result_code, sizeof (result_code));
 850     } while (ret == -1 && errno == EINTR);
 851
 852     if (ret == -1) {
 853       g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 854           _("Error re-scanning registry %s: %s"),
 855           ", read returned error", g_strerror (errno));
 856       close (pfd[0]);
 857       return FALSE;
 858     }
 859     (void) close (pfd[0]);
 860
 861     /* Wait to ensure the child is reaped, but ignore the result */
 862     GST_DEBUG ("parent waiting on child");
 863     waitpid (pid, NULL, 0);
 864     GST_DEBUG ("parent done waiting on child");
 865
 866     if (ret == 0) {
 867       GST_ERROR ("child did not exit normally, terminated by signal");
 868       g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
 869           _("Error re-scanning registry %s"), ", child terminated by signal");
 870       return FALSE;
 871     }
 872
 873     if (result_code == REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED) {
 874       GST_DEBUG ("Child succeeded. Parent reading registry cache");
 875       _priv_gst_registry_remove_cache_plugins (default_registry);
 876 #ifdef USE_BINARY_REGISTRY
 877       gst_registry_binary_read_cache (default_registry, registry_file);
 878 #else
 879       gst_registry_xml_read_cache (default_registry, registry_file);
 880 #endif
 881     } else if (result_code == REGISTRY_SCAN_AND_UPDATE_FAILURE) {
 882       GST_DEBUG ("Child failed. Parent re-scanning registry, ignoring errors.");
 883       scan_and_update_registry (default_registry, registry_file, FALSE, NULL);
 884     }
 885   }
 886 #endif /* HAVE_FORK */
 887   return TRUE;
 888 }
 889
 890 static gboolean
 891 ensure_current_registry (GError ** error)
 892 {
 893   char *registry_file;
 894   GstRegistry *default_registry;
 895   gboolean ret;
 896   gboolean do_fork;
 897
 898   default_registry = gst_registry_get_default ();
 899   registry_file = g_strdup (g_getenv ("GST_REGISTRY"));
 900   if (registry_file == NULL) {
 901 #ifdef USE_BINARY_REGISTRY
 902     registry_file = g_build_filename (g_get_home_dir (),
 903         ".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".bin", NULL);
 904 #else
 905     registry_file = g_build_filename (g_get_home_dir (),
 906         ".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".xml", NULL);
 907 #endif
 908   }
 909
 910   /* first see if forking is enabled */
 911   do_fork = _gst_enable_registry_fork;
 912   if (do_fork) {
 913     const gchar *fork_env;
 914
 915     /* forking enabled, see if it is disabled with an env var */
 916     if ((fork_env = g_getenv ("GST_REGISTRY_FORK"))) {
 917       /* fork enabled for any value different from "no" */
 918       do_fork = strcmp (fork_env, "no") != 0;
 919     }
 920   }
 921
 922   /* now check registry with or without forking */
 923   if (do_fork) {
 924     GST_DEBUG ("forking for registry rebuild");
 925     ret = ensure_current_registry_forking (default_registry, registry_file,
 926         error);
 927   } else {
 928     GST_DEBUG ("requested not to fork for registry rebuild");
 929     ret = ensure_current_registry_nonforking (default_registry, registry_file,
 930         error);
 931   }
 932
 933   g_free (registry_file);
 934
 935   return ret;
 936 }
 937 #endif /* GST_DISABLE_REGISTRY */
 938
 939 /*
 940  * this bit handles:
 941  * - initalization of threads if we use them
 942  * - log handler
 943  * - initial output
 944  * - initializes gst_format
 945  * - registers a bunch of types for gst_objects
 946  *
 947  * - we don't have cases yet where this fails, but in the future
 948  *   we might and then it's nice to be able to return that
 949  */
 950 static gboolean
 951 init_post (GOptionContext * context, GOptionGroup * group, gpointer data,
 952     GError ** error)
 953 {
 954   GLogLevelFlags llf;
 955
 956 #ifndef GST_DISABLE_TRACE
 957   GstTrace *gst_trace;
 958 #endif /* GST_DISABLE_TRACE */
 959
 960   if (gst_initialized) {
 961     GST_DEBUG ("already initialized");
 962     return TRUE;
 963   }
 964
 965   llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
 966   g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
 967
 968   _priv_gst_quarks_initialize ();
 969   _gst_format_initialize ();
 970   _gst_query_initialize ();
 971   gst_object_get_type ();
 972   gst_pad_get_type ();
 973   gst_element_factory_get_type ();
 974   gst_element_get_type ();
 975   gst_type_find_factory_get_type ();
 976   gst_bin_get_type ();
 977
 978 #ifndef GST_DISABLE_INDEX
 979   gst_index_factory_get_type ();
 980 #endif /* GST_DISABLE_INDEX */
 981 #ifndef GST_DISABLE_URI
 982   gst_uri_handler_get_type ();
 983 #endif /* GST_DISABLE_URI */
 984
 985   gst_structure_get_type ();
 986   _gst_value_initialize ();
 987   gst_param_spec_fraction_get_type ();
 988   gst_caps_get_type ();
 989   _gst_event_initialize ();
 990   _gst_buffer_initialize ();
 991   _gst_message_initialize ();
 992   _gst_tag_initialize ();
 993
 994   /* register core plugins */
 995   _gst_plugin_register_static (&plugin_desc);
 996
 997   _gst_plugin_initialize ();
 998
 999   /*
1000    * Any errors happening below this point are non-fatal, we therefore mark
1001    * gstreamer as being initialized, since it is the case from a plugin point of
1002    * view.
1003    *
1004    * If anything fails, it will be put back to FALSE in gst_init_check().
1005    * This allows some special plugins that would call gst_init() to not cause a
1006    * looping effect (i.e. initializing GStreamer twice).
1007    */
1008   gst_initialized = TRUE;
1009
1010 #ifndef GST_DISABLE_REGISTRY
1011   if (!ensure_current_registry (error))
1012     return FALSE;
1013 #endif /* GST_DISABLE_REGISTRY */
1014
1015   /* if we need to preload plugins, do so now */
1016   g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1017   /* keep preload_plugins around in case a re-scan is forced later on */
1018
1019 #ifndef GST_DISABLE_TRACE
1020   _gst_trace_on = 0;
1021   if (_gst_trace_on) {
1022     gst_trace = gst_trace_new ("gst.trace", 1024);
1023     gst_trace_set_default (gst_trace);
1024   }
1025 #endif /* GST_DISABLE_TRACE */
1026
1027   return TRUE;
1028 }
1029
1030 #ifndef GST_DISABLE_GST_DEBUG
1031 static gboolean
1032 select_all (GstPlugin * plugin, gpointer user_data)
1033 {
1034   return TRUE;
1035 }
1036
1037 static gint
1038 sort_by_category_name (gconstpointer a, gconstpointer b)
1039 {
1040   return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
1041       gst_debug_category_get_name ((GstDebugCategory *) b));
1042 }
1043
1044 static void
1045 gst_debug_help (void)
1046 {
1047   GSList *list, *walk;
1048   GList *list2, *g;
1049
1050   /* Need to ensure the registry is loaded to get debug categories */
1051   if (!init_post (NULL, NULL, NULL, NULL))
1052     exit (1);
1053
1054   list2 = gst_registry_plugin_filter (gst_registry_get_default (),
1055       select_all, FALSE, NULL);
1056
1057   /* FIXME this is gross.  why don't debug have categories PluginFeatures? */
1058   for (g = list2; g; g = g_list_next (g)) {
1059     GstPlugin *plugin = GST_PLUGIN_CAST (g->data);
1060
1061     gst_plugin_load (plugin);
1062   }
1063   g_list_free (list2);
1064
1065   list = gst_debug_get_all_categories ();
1066   walk = list = g_slist_sort (list, sort_by_category_name);
1067
1068   g_print ("\n");
1069   g_print ("name                  level    description\n");
1070   g_print ("---------------------+--------+--------------------------------\n");
1071
1072   while (walk) {
1073     GstDebugCategory *cat = (GstDebugCategory *) walk->data;
1074
1075     if (gst_debug_is_colored ()) {
1076       gchar *color = gst_debug_construct_term_color (cat->color);
1077
1078       g_print ("%s%-20s\033[00m  %1d %s  %s%s\033[00m\n",
1079           color,
1080           gst_debug_category_get_name (cat),
1081           gst_debug_category_get_threshold (cat),
1082           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1083           color, gst_debug_category_get_description (cat));
1084       g_free (color);
1085     } else {
1086       g_print ("%-20s  %1d %s  %s\n", gst_debug_category_get_name (cat),
1087           gst_debug_category_get_threshold (cat),
1088           gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
1089           gst_debug_category_get_description (cat));
1090     }
1091     walk = g_slist_next (walk);
1092   }
1093   g_slist_free (list);
1094   g_print ("\n");
1095 }
1096 #endif
1097
1098 #ifndef GST_DISABLE_OPTION_PARSING
1099 static gboolean
1100 parse_one_option (gint opt, const gchar * arg, GError ** err)
1101 {
1102   switch (opt) {
1103     case ARG_VERSION:
1104       g_print ("GStreamer Core Library version %s\n", PACKAGE_VERSION);
1105       exit (0);
1106     case ARG_FATAL_WARNINGS:{
1107       GLogLevelFlags fatal_mask;
1108
1109       fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
1110       fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
1111       g_log_set_always_fatal (fatal_mask);
1112       break;
1113     }
1114 #ifndef GST_DISABLE_GST_DEBUG
1115     case ARG_DEBUG_LEVEL:{
1116       gint tmp = 0;
1117
1118       tmp = strtol (arg, NULL, 0);
1119       if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
1120         gst_debug_set_default_threshold (tmp);
1121       }
1122       break;
1123     }
1124     case ARG_DEBUG:
1125       parse_debug_list (arg);
1126       break;
1127     case ARG_DEBUG_NO_COLOR:
1128       gst_debug_set_colored (FALSE);
1129       break;
1130     case ARG_DEBUG_DISABLE:
1131       gst_debug_set_active (FALSE);
1132       break;
1133     case ARG_DEBUG_HELP:
1134       gst_debug_help ();
1135       exit (0);
1136 #endif
1137     case ARG_PLUGIN_SPEW:
1138       break;
1139     case ARG_PLUGIN_PATH:
1140 #ifndef GST_DISABLE_REGISTRY
1141       split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func, NULL);
1142 #endif /* GST_DISABLE_REGISTRY */
1143       break;
1144     case ARG_PLUGIN_LOAD:
1145       split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
1146       break;
1147     case ARG_SEGTRAP_DISABLE:
1148       _gst_disable_segtrap = TRUE;
1149       break;
1150     case ARG_REGISTRY_FORK_DISABLE:
1151       _gst_enable_registry_fork = FALSE;
1152       break;
1153     default:
1154       g_set_error (err, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION,
1155           _("Unknown option"));
1156       return FALSE;
1157   }
1158
1159   return TRUE;
1160 }
1161
1162 static gboolean
1163 parse_goption_arg (const gchar * opt,
1164     const gchar * arg, gpointer data, GError ** err)
1165 {
1166   static const struct
1167   {
1168     gchar *opt;
1169     int val;
1170   } options[] = {
1171     {
1172     "--gst-version", ARG_VERSION}, {
1173     "--gst-fatal-warnings", ARG_FATAL_WARNINGS},
1174 #ifndef GST_DISABLE_GST_DEBUG
1175     {
1176     "--gst-debug-level", ARG_DEBUG_LEVEL}, {
1177     "--gst-debug", ARG_DEBUG}, {
1178     "--gst-debug-disable", ARG_DEBUG_DISABLE}, {
1179     "--gst-debug-no-color", ARG_DEBUG_NO_COLOR}, {
1180     "--gst-debug-help", ARG_DEBUG_HELP},
1181 #endif
1182     {
1183     "--gst-plugin-spew", ARG_PLUGIN_SPEW}, {
1184     "--gst-plugin-path", ARG_PLUGIN_PATH}, {
1185     "--gst-plugin-load", ARG_PLUGIN_LOAD}, {
1186     "--gst-disable-segtrap", ARG_SEGTRAP_DISABLE}, {
1187     "--gst-disable-registry-fork", ARG_REGISTRY_FORK_DISABLE}, {
1188     NULL}
1189   };
1190   gint val = 0, n;
1191
1192   for (n = 0; options[n].opt; n++) {
1193     if (!strcmp (opt, options[n].opt)) {
1194       val = options[n].val;
1195       break;
1196     }
1197   }
1198
1199   return parse_one_option (val, arg, err);
1200 }
1201 #endif
1202
1203 extern GstRegistry *_gst_registry_default;
1204
1205 /**
1206  * gst_deinit:
1207  *
1208  * Clean up any resources created by GStreamer in gst_init().
1209  *
1210  * It is normally not needed to call this function in a normal application
1211  * as the resources will automatically be freed when the program terminates.
1212  * This function is therefore mostly used by testsuites and other memory
1213  * profiling tools.
1214  *
1215  * After this call GStreamer (including this method) should not be used anymore.
1216  */
1217 void
1218 gst_deinit (void)
1219 {
1220   GstClock *clock;
1221
1222   GST_INFO ("deinitializing GStreamer");
1223
1224   if (!gst_initialized) {
1225     GST_DEBUG ("already deinitialized");
1226     return;
1227   }
1228
1229   g_slist_foreach (preload_plugins, (GFunc) g_free, NULL);
1230   g_slist_free (preload_plugins);
1231   preload_plugins = NULL;
1232
1233 #ifndef GST_DISABLE_REGISTRY
1234   g_list_foreach (plugin_paths, (GFunc) g_free, NULL);
1235   g_list_free (plugin_paths);
1236   plugin_paths = NULL;
1237 #endif
1238
1239   clock = gst_system_clock_obtain ();
1240   gst_object_unref (clock);
1241   gst_object_unref (clock);
1242
1243   _priv_gst_registry_cleanup ();
1244
1245   gst_initialized = FALSE;
1246   GST_INFO ("deinitialized GStreamer");
1247 }
1248
1249 /**
1250  * gst_version:
1251  * @major: pointer to a guint to store the major version number
1252  * @minor: pointer to a guint to store the minor version number
1253  * @micro: pointer to a guint to store the micro version number
1254  * @nano:  pointer to a guint to store the nano version number
1255  *
1256  * Gets the version number of the GStreamer library.
1257  */
1258 void
1259 gst_version (guint * major, guint * minor, guint * micro, guint * nano)
1260 {
1261   g_return_if_fail (major);
1262   g_return_if_fail (minor);
1263   g_return_if_fail (micro);
1264   g_return_if_fail (nano);
1265
1266   *major = GST_VERSION_MAJOR;
1267   *minor = GST_VERSION_MINOR;
1268   *micro = GST_VERSION_MICRO;
1269   *nano = GST_VERSION_NANO;
1270 }
1271
1272 /**
1273  * gst_version_string:
1274  *
1275  * This function returns a string that is useful for describing this version
1276  * of GStreamer to the outside world: user agent strings, logging, ...
1277  *
1278  * Returns: a newly allocated string describing this version of GStreamer.
1279  */
1280
1281 gchar *
1282 gst_version_string ()
1283 {
1284   guint major, minor, micro, nano;
1285
1286   gst_version (&major, &minor, &micro, &nano);
1287   if (nano == 0)
1288     return g_strdup_printf ("GStreamer %d.%d.%d", major, minor, micro);
1289   else if (nano == 1)
1290     return g_strdup_printf ("GStreamer %d.%d.%d (CVS)", major, minor, micro);
1291   else
1292     return g_strdup_printf ("GStreamer %d.%d.%d (prerelease)", major, minor,
1293         micro);
1294 }
1295
1296 /**
1297  * gst_segtrap_is_enabled:
1298  *
1299  * Some functions in the GStreamer core might install a custom SIGSEGV handler
1300  * to better catch and report errors to the application. Currently this feature
1301  * is enabled by default when loading plugins.
1302  *
1303  * Applications might want to disable this behaviour with the
1304  * gst_segtrap_set_enabled() function. This is typically done if the application
1305  * wants to install its own handler without GStreamer interfering.
1306  *
1307  * Returns: %TRUE if GStreamer is allowed to install a custom SIGSEGV handler.
1308  *
1309  * Since: 0.10.10
1310  */
1311 gboolean
1312 gst_segtrap_is_enabled (void)
1313 {
1314   /* yeps, it's enabled when it's not disabled */
1315   return !_gst_disable_segtrap;
1316 }
1317
1318 /**
1319  * gst_segtrap_set_enabled:
1320  * @enabled: whether a custom SIGSEGV handler should be installed.
1321  *
1322  * Applications might want to disable/enable the SIGSEGV handling of
1323  * the GStreamer core. See gst_segtrap_is_enabled() for more information.
1324  *
1325  * Since: 0.10.10
1326  */
1327 void
1328 gst_segtrap_set_enabled (gboolean enabled)
1329 {
1330   _gst_disable_segtrap = !enabled;
1331 }
1332
1333 /**
1334  * gst_registry_fork_is_enabled:
1335  *
1336  * By default GStreamer will perform a fork() when scanning and rebuilding the
1337  * registry file.
1338  *
1339  * Applications might want to disable this behaviour with the
1340  * gst_registry_fork_set_enabled() function.
1341  *
1342  * Returns: %TRUE if GStreamer will use fork() when rebuilding the registry. On
1343  * platforms without fork(), this function will always return %FALSE.
1344  *
1345  * Since: 0.10.10
1346  */
1347 gboolean
1348 gst_registry_fork_is_enabled (void)
1349 {
1350   return _gst_enable_registry_fork;
1351 }
1352
1353 /**
1354  * gst_registry_fork_set_enabled:
1355  * @enabled: whether rebuilding the registry may fork
1356  *
1357  * Applications might want to disable/enable the usage of fork() when rebuilding
1358  * the registry. See gst_registry_fork_is_enabled() for more information.
1359  *
1360  * On platforms without fork(), this function will have no effect on the return
1361  * value of gst_registry_fork_is_enabled().
1362  *
1363  * Since: 0.10.10
1364  */
1365 void
1366 gst_registry_fork_set_enabled (gboolean enabled)
1367 {
1368 #ifdef HAVE_FORK
1369   _gst_enable_registry_fork = enabled;
1370 #endif /* HAVE_FORK */
1371 }
1372
1373
1374 /**
1375  * gst_update_registry:
1376  *
1377  * Forces GStreamer to re-scan its plugin paths and update the default
1378  * plugin registry.
1379  *
1380  * Applications will almost never need to call this function, it is only
1381  * useful if the application knows new plugins have been installed (or old
1382  * ones removed) since the start of the application (or, to be precise, the
1383  * first call to gst_init()) and the application wants to make use of any
1384  * newly-installed plugins without restarting the application.
1385  *
1386  * Applications should assume that the registry update is neither atomic nor
1387  * thread-safe and should therefore not have any dynamic pipelines running
1388  * (including the playbin and decodebin elements) and should also not create
1389  * any elements or access the GStreamer registry while the update is in
1390  * progress.
1391  *
1392  * Note that this function may block for a significant amount of time.
1393  *
1394  * Returns: %TRUE if the registry has been updated successfully (does not
1395  *          imply that there were changes), otherwise %FALSE.
1396  *
1397  * Since: 0.10.12
1398  */
1399 gboolean
1400 gst_update_registry (void)
1401 {
1402   gboolean res = FALSE;
1403
1404 #ifndef GST_DISABLE_REGISTRY
1405   GError *err = NULL;
1406
1407   res = ensure_current_registry (&err);
1408   if (err) {
1409     GST_WARNING ("registry update failed: %s", err->message);
1410     g_error_free (err);
1411   } else {
1412     GST_LOG ("registry update succeeded");
1413   }
1414
1415   if (preload_plugins) {
1416     g_slist_foreach (preload_plugins, load_plugin_func, NULL);
1417   }
1418 #else
1419   GST_WARNING ("registry update failed: %s", "registry disabled");
1420 #endif /* GST_DISABLE_REGISTRY */
1421
1422   return res;
1423 }