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