gst/gst.c

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