gst/gst.c

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