/* GStreamer

 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>

 *                    2000 Wim Taymans <wtay@chello.be>

 *

 * gst.c: Initialization and non-pipeline operations

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:gst

 * @short_description: Media library supporting arbitrary formats and filter

 *                     graphs.

 * @see_also: Check out both <ulink url="http://www.cse.ogi.edu/sysl/">OGI's

 *            pipeline</ulink> and Microsoft's DirectShow for some background.

 *

 * GStreamer is a framework for constructing graphs of various filters

 * (termed elements here) that will handle streaming media.  Any discreet

 * (packetizable) media type is supported, with provisions for automatically

 * determining source type.  Formatting/framing information is provided with

 * a powerful negotiation framework.  Plugins are heavily used to provide for

 * all elements, allowing one to construct plugins outside of the GST

 * library, even released binary-only if license require (please don't).

 *

 * GStreamer borrows heavily from both the <ulink

 * url="http://www.cse.ogi.edu/sysl/">OGI media pipeline</ulink> and

 * Microsoft's DirectShow, hopefully taking the best of both and leaving the

 * cruft behind. Its interface is slowly getting stable.

 *

 * The <application>GStreamer</application> library should be initialized with

 * gst_init() before it can be used. You should pass pointers to the main argc

 * and argv variables so that GStreamer can process its own command line

 * options, as shown in the following example.

 *

 * <example>

 * <title>Initializing the gstreamer library</title>

 * <programlisting language="c">

 * int

 * main (int argc, char *argv[])

 * {

 *   // initialize the GStreamer library

 *   gst_init (&argc, &argv);

 *   ...

 * }

 * </programlisting>

 * </example>

 *

 * It's allowed to pass two NULL pointers to gst_init() in case you don't want

 * to pass the command line args to GStreamer.

 *

 * You can also use GOption to initialize your own parameters as shown in

 * the next code fragment:

 * <example>

 * <title>Initializing own parameters when initializing gstreamer</title>

 * <programlisting>

 * static gboolean stats = FALSE;

 * ...

 * int

 * main (int argc, char *argv[])

 * {

 *  GOptionEntry options[] = {

 *   {"tags", 't', 0, G_OPTION_ARG_NONE, &tags,

 *       N_("Output tags (also known as metadata)"), NULL},

 *   {NULL}

 *  };

 *  // must initialise the threading system before using any other GLib funtion

 *  if (!g_thread_supported ())

 *    g_thread_init (NULL);

 *  ctx = g_option_context_new ("[ADDITIONAL ARGUMENTS]");

 *  g_option_context_add_main_entries (ctx, options, GETTEXT_PACKAGE);

 *  g_option_context_add_group (ctx, gst_init_get_option_group ());

 *  if (!g_option_context_parse (ctx, &argc, &argv, &err)) {

 *    g_print ("Error initializing: %s\n", GST_STR_NULL (err->message));

 *    exit (1);

 *  }

 *  g_option_context_free (ctx);

 * ...

 * }

 * </programlisting>

 * </example>

 *

 * Use gst_version() to query the library version at runtime or use the

 * GST_VERSION_* macros to find the version at compile time. Optionally

 * gst_version_string() returns a printable string.

 *

 * The gst_deinit() call is used to clean up all internal resources used

 * by <application>GStreamer</application>. It is mostly used in unit tests 

 * to check for leaks.

 *

 * Last reviewed on 2006-08-11 (0.10.10)

 */

#include "gst_private.h"

#include <stdlib.h>

#include <stdio.h>

#include <sys/types.h>

#ifdef HAVE_FORK

#include <sys/wait.h>

#endif /* HAVE_FORK */

#ifdef HAVE_SYS_UTSNAME_H

#include <sys/utsname.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include "gst-i18n-lib.h"

#include <locale.h>             /* for LC_ALL */

#include "gst.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#include <config.h>

#endif

#define GST_CAT_DEFAULT GST_CAT_GST_INIT

#define MAX_PATH_SPLIT  16

#define GST_PLUGIN_SEPARATOR ","

static gboolean gst_initialized = FALSE;

static gboolean gst_deinitialized = FALSE;

#ifndef GST_DISABLE_REGISTRY

static GList *plugin_paths = NULL;      /* for delayed processing in post_init */

#endif

#ifndef GST_DISABLE_GST_DEBUG

extern const gchar *priv_gst_dump_dot_dir;

#endif

/* defaults */

#define DEFAULT_FORK TRUE

#else

#define DEFAULT_FORK FALSE

#endif /* HAVE_FORK */

/* set to TRUE when segfaults need to be left as is */

static gboolean _gst_disable_segtrap = FALSE;

/* control the behaviour of registry rebuild */

static gboolean _gst_enable_registry_fork = DEFAULT_FORK;

/*set to TRUE when registry needn't to be updated */

static gboolean _gst_disable_registry_update = FALSE;

static void load_plugin_func (gpointer data, gpointer user_data);

static gboolean init_pre (GOptionContext * context, GOptionGroup * group,

    gpointer data, GError ** error);

static gboolean init_post (GOptionContext * context, GOptionGroup * group,

    gpointer data, GError ** error);

#ifndef GST_DISABLE_OPTION_PARSING

static gboolean parse_goption_arg (const gchar * s_opt,

    const gchar * arg, gpointer data, GError ** err);

#endif

static GSList *preload_plugins = NULL;

const gchar g_log_domain_gstreamer[] = "GStreamer";

static void

debug_log_handler (const gchar * log_domain,

    GLogLevelFlags log_level, const gchar * message, gpointer user_data)

{

  g_log_default_handler (log_domain, log_level, message, user_data);

  /* FIXME: do we still need this ? fatal errors these days are all

   * other than core errors */

  /* g_on_error_query (NULL); */

}

enum

{

  ARG_VERSION = 1,

  ARG_FATAL_WARNINGS,

#ifndef GST_DISABLE_GST_DEBUG

  ARG_DEBUG_LEVEL,

  ARG_DEBUG,

  ARG_DEBUG_DISABLE,

  ARG_DEBUG_NO_COLOR,

  ARG_DEBUG_HELP,

#endif

  ARG_PLUGIN_SPEW,

  ARG_PLUGIN_PATH,

  ARG_PLUGIN_LOAD,

  ARG_SEGTRAP_DISABLE,

  ARG_REGISTRY_UPDATE_DISABLE,

  ARG_REGISTRY_FORK_DISABLE

};

/* debug-spec ::= category-spec [, category-spec]*

 * category-spec ::= category:val | val

 * category ::= [^:]+

 * val ::= [0-5]

 */

#ifndef NUL

#define NUL '\0'

#endif

#ifndef GST_DISABLE_GST_DEBUG

static gboolean

parse_debug_category (gchar * str, const gchar ** category)

{

  if (!str)

    return FALSE;

  /* works in place */

  g_strstrip (str);

  if (str[0] != NUL) {

    *category = str;

    return TRUE;

  }

  return FALSE;

}

static gboolean

parse_debug_level (gchar * str, gint * level)

{

  if (!str)

    return FALSE;

  /* works in place */

  g_strstrip (str);

  if (str[0] != NUL && str[1] == NUL

      && str[0] >= '0' && str[0] < '0' + GST_LEVEL_COUNT) {

    *level = str[0] - '0';

    return TRUE;

  }

  return FALSE;

}

static void

parse_debug_list (const gchar * list)

{

  gchar **split;

  gchar **walk;

  g_return_if_fail (list != NULL);

  split = g_strsplit (list, ",", 0);

  for (walk = split; *walk; walk++) {

    if (strchr (*walk, ':')) {

      gchar **values = g_strsplit (*walk, ":", 2);

      if (values[0] && values[1]) {

        gint level;

        const gchar *category;

        if (parse_debug_category (values[0], &category)

            && parse_debug_level (values[1], &level))

          gst_debug_set_threshold_for_name (category, level);

      }

      g_strfreev (values);

    } else {

      gint level;

      if (parse_debug_level (*walk, &level))

        gst_debug_set_default_threshold (level);

    }

  }

  g_strfreev (split);

}

#endif

/**

 * gst_init_get_option_group:

 *

 * Returns a #GOptionGroup with GStreamer's argument specifications. The

 * group is set up to use standard GOption callbacks, so when using this

 * group in combination with GOption parsing methods, all argument parsing

 * and initialization is automated.

 *

 * This function is useful if you want to integrate GStreamer with other

 * libraries that use GOption (see g_option_context_add_group() ).

 *

 * If you use this function, you should make sure you initialise the GLib

 * threading system as one of the very first things in your program

 * (see the example at the beginning of this section).

 *

 * Returns: a pointer to GStreamer's option group.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

GOptionGroup *

gst_init_get_option_group (void)

{

#ifndef GST_DISABLE_OPTION_PARSING

  GOptionGroup *group;

    {"gst-version", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,

        (gpointer) parse_goption_arg, N_("Print the GStreamer version"), NULL},

    {"gst-fatal-warnings", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,

        (gpointer) parse_goption_arg, N_("Make all warnings fatal"), NULL},

#ifndef GST_DISABLE_GST_DEBUG

    {"gst-debug-help", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

          N_("Print available debug categories and exit"),

        NULL},

    {"gst-debug-level", 0, 0, G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

          N_("Default debug level from 1 (only error) to 5 (anything) or "

              "0 for no output"),

        N_("LEVEL")},

    {"gst-debug", 0, 0, G_OPTION_ARG_CALLBACK, (gpointer) parse_goption_arg,

          N_("Comma-separated list of category_name:level pairs to set "

              "specific levels for the individual categories. Example: "

              "GST_AUTOPLUG:5,GST_ELEMENT_*:3"),

        N_("LIST")},

    {"gst-debug-no-color", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg, N_("Disable colored debugging output"),

        NULL},

    {"gst-debug-disable", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,

        (gpointer) parse_goption_arg, N_("Disable debugging"), NULL},

#endif

    {"gst-plugin-spew", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

          N_("Enable verbose plugin loading diagnostics"),

        NULL},

    {"gst-plugin-path", 0, 0, G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

        N_("Colon-separated paths containing plugins"), N_("PATHS")},

    {"gst-plugin-load", 0, 0, G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

          N_("Comma-separated list of plugins to preload in addition to the "

              "list stored in environment variable GST_PLUGIN_PATH"),

        N_("PLUGINS")},

    {"gst-disable-segtrap", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

          N_("Disable trapping of segmentation faults during plugin loading"),

        NULL},

    {"gst-disable-registry-update", 0, G_OPTION_FLAG_NO_ARG,

          G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

          N_("Disable updating the registry"),

        NULL},

    {"gst-disable-registry-fork", 0, G_OPTION_FLAG_NO_ARG,

          G_OPTION_ARG_CALLBACK,

          (gpointer) parse_goption_arg,

          N_("Disable the use of fork() while scanning the registry"),

        NULL},

    {NULL}

  };

  /* The GLib threading system must be initialised before calling any other

   * GLib function according to the documentation; if the application hasn't

   * called gst_init() yet or initialised the threading system otherwise, we

   * better issue a warning here (since chances are high that the application

   * has already called other GLib functions such as g_option_context_new() */

  if (!g_thread_supported ()) {

    g_warning ("The GStreamer function gst_init_get_option_group() was\n"

        "\tcalled, but the GLib threading system has not been initialised\n"

        "\tyet, something that must happen before any other GLib function\n"

        "\tis called. The application needs to be fixed so that it calls\n"

        "\t   if (!g_thread_supported ()) g_thread_init(NULL);\n"

        "\tas very first thing in its main() function. Please file a bug\n"

        "\tagainst this application.");

    g_thread_init (NULL);

  }

  group = g_option_group_new ("gst", _("GStreamer Options"),

      _("Show GStreamer Options"), NULL, NULL);

  g_option_group_set_parse_hooks (group, (GOptionParseFunc) init_pre,

      (GOptionParseFunc) init_post);

  g_option_group_add_entries (group, gst_args);

  g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);

  return group;

#else

  return NULL;

#endif

}

/**

 * gst_init_check:

 * @argc: pointer to application's argc

 * @argv: pointer to application's argv

 * @err: pointer to a #GError to which a message will be posted on error

 *

 * Initializes the GStreamer library, setting up internal path lists,

 * registering built-in elements, and loading standard plugins.

 *

 * This function will return %FALSE if GStreamer could not be initialized

 * for some reason.  If you want your program to fail fatally,

 * use gst_init() instead.

 *

 * This function should be called before calling any other GLib functions. If

 * this is not an option, your program must initialise the GLib thread system

 * using g_thread_init() before any other GLib functions are called.

 *

 * Returns: %TRUE if GStreamer could be initialized.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

gboolean

gst_init_check (int *argc, char **argv[], GError ** err)

{

#ifndef GST_DISABLE_OPTION_PARSING

  GOptionGroup *group;

  GOptionContext *ctx;

#endif

  gboolean res;

  if (!g_thread_supported ())

    g_thread_init (NULL);

  if (gst_initialized) {

    GST_DEBUG ("already initialized gst");

    return TRUE;

  }

#ifndef GST_DISABLE_OPTION_PARSING

  ctx = g_option_context_new ("- GStreamer initialization");

  g_option_context_set_ignore_unknown_options (ctx, TRUE);

  group = gst_init_get_option_group ();

  g_option_context_add_group (ctx, group);

  res = g_option_context_parse (ctx, argc, argv, err);

  g_option_context_free (ctx);

#else

  init_pre (NULL, NULL, NULL, NULL);

  init_post (NULL, NULL, NULL, NULL);

  res = TRUE;

#endif

  gst_initialized = res;

  if (res) {

    GST_INFO ("initialized GStreamer successfully");

  } else {

    GST_INFO ("failed to initialize GStreamer");

  }

  return res;

}

/**

 * gst_init:

 * @argc: pointer to application's argc

 * @argv: pointer to application's argv

 *

 * Initializes the GStreamer library, setting up internal path lists,

 * registering built-in elements, and loading standard plugins.

 *

 * This function should be called before calling any other GLib functions. If

 * this is not an option, your program must initialise the GLib thread system

 * using g_thread_init() before any other GLib functions are called.

 *

 * <note><para>

 * This function will terminate your program if it was unable to initialize

 * GStreamer for some reason.  If you want your program to fall back,

 * use gst_init_check() instead.

 * </para></note>

 *

 * WARNING: This function does not work in the same way as corresponding

 * functions in other glib-style libraries, such as gtk_init().  In

 * particular, unknown command line options cause this function to

 * abort program execution.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

void

gst_init (int *argc, char **argv[])

{

  GError *err = NULL;

  if (!gst_init_check (argc, argv, &err)) {

    g_print ("Could not initialize GStreamer: %s\n",

        err ? err->message : "unknown error occurred");

    if (err) {

      g_error_free (err);

    }

    exit (1);

  }

}

#ifndef GST_DISABLE_REGISTRY

static void