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