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