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