2000-12-28 22:12:02 +00:00
|
|
|
/* GStreamer
|
|
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
|
|
*
|
|
|
|
* gst.c: Initialization and non-pipeline operations
|
2000-01-30 09:03:00 +00:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2001-01-01 03:43:27 +00:00
|
|
|
#include <stdlib.h>
|
2002-02-16 03:24:50 +00:00
|
|
|
#include <stdio.h>
|
2001-01-01 03:43:27 +00:00
|
|
|
|
2000-12-28 22:12:02 +00:00
|
|
|
#include "gst_private.h"
|
2004-01-13 11:30:00 +00:00
|
|
|
#include "gst-i18n-lib.h"
|
2004-03-15 19:27:17 +00:00
|
|
|
#include <locale.h> /* for LC_ALL */
|
2000-12-28 22:12:02 +00:00
|
|
|
|
2001-12-04 22:12:50 +00:00
|
|
|
#include "gst.h"
|
2001-01-19 00:01:42 +00:00
|
|
|
#include "gstqueue.h"
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2002-05-08 20:40:48 +00:00
|
|
|
#include "registries/gstxmlregistry.h"
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_REGISTRY */
|
|
|
|
#include "gstregistrypool.h"
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
#define GST_CAT_DEFAULT GST_CAT_GST_INIT
|
|
|
|
|
2001-02-24 00:23:21 +00:00
|
|
|
#define MAX_PATH_SPLIT 16
|
2001-10-17 10:21:27 +00:00
|
|
|
#define GST_PLUGIN_SEPARATOR ","
|
2000-12-29 10:02:17 +00:00
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2004-06-12 13:45:17 +00:00
|
|
|
gboolean _gst_registry_auto_load = TRUE;
|
2002-05-08 20:40:48 +00:00
|
|
|
static GstRegistry *_global_registry;
|
|
|
|
static GstRegistry *_user_registry;
|
2002-05-11 20:30:05 +00:00
|
|
|
static gboolean _gst_registry_fixed = FALSE;
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif
|
|
|
|
|
2003-05-31 02:04:59 +00:00
|
|
|
static gboolean _gst_enable_cpu_opt = TRUE;
|
|
|
|
|
2002-11-27 21:08:06 +00:00
|
|
|
static gboolean gst_initialized = FALSE;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-11-27 21:08:06 +00:00
|
|
|
/* this will be set in popt callbacks when a problem has been encountered */
|
|
|
|
static gboolean _gst_initialization_failure = FALSE;
|
2000-01-30 09:03:00 +00:00
|
|
|
extern gint _gst_trace_on;
|
|
|
|
|
2003-12-15 12:44:35 +00:00
|
|
|
/* set to TRUE when segfaults need to be left as is */
|
2003-12-16 12:20:54 +00:00
|
|
|
gboolean _gst_disable_segtrap = FALSE;
|
2003-12-15 12:44:35 +00:00
|
|
|
|
2002-06-21 14:50:00 +00:00
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
static void load_plugin_func (gpointer data, gpointer user_data);
|
|
|
|
static void init_popt_callback (poptContext context,
|
|
|
|
enum poptCallbackReason reason,
|
|
|
|
const GstPoptOption * option, const char *arg, void *data);
|
|
|
|
static gboolean init_pre (void);
|
|
|
|
static gboolean init_post (void);
|
2001-10-17 10:21:27 +00:00
|
|
|
|
|
|
|
static GSList *preload_plugins = NULL;
|
WARNING: Don't grab this updated unless you're really, REALLY sure.
Original commit message from CVS:
WARNING: Don't grab this updated unless you're really, REALLY sure.
WARNING: Wait for the next one.
Whole lotta changes here, including a few random bits:
examples/*/Makefile: updated to use `libtool gcc`, not just `gcc`
gst/
gstbuffer.h: updated to new flag style
gst.c, gstdebug.h: added new debugging for function ptrs
gstpipeline.c: set type of parent_class to the class, not the object
gstthread.c: ditto
plugins/
cdparanoia/cdparanoia.c: added an argument type, updated some defaults
cobin/spindentity.c: updated to new do/while loopfunction style
mp3encode/lame/gstlame.c: argument types, whole lotta lame options
tests/: various changes
Now, for the big changes: Once again, the scheduling system has changed.
And once again, it broke a whole bunch of things. The gist of the change
is that there is now a function pointer for gst_pad_push and gst_pad_pull,
instead of a hard-wired function. Well, currently they are functions, but
that's for debugging purposes only, they just call the function pointer
after spewing lots of DEBUG().
This changed the GstPad structure a bit, and the GstPad API as well.
Where elements used to provide chain() and pull() functions, they provide
chain() and get() functions. gst_pad_set_pull[region]_function has been
changed to get_pad_set_get[region]_function. This means all the elements
out there that used to have pull functions need to be updated. The calls
to that function have been changed in the normal elements, but the names
of the functions passed is still _pull[region](), which is an aesthetic
issue more than anything.
As for what doesn't work yet, just about anything dealing with Connections
is hosed, meaning threaded stuff won't work. This will be fixed about 12
hours from now, after I've slept, etc. The simplefake.c test works in
both cothreaded and chained cases, but not much else will work due to the
Connection problem. Needless to say, don't grab this unless you *need*
these features *now*, else wait to update this stuff until tomorrow.
I'm going to sleep now.
2000-12-16 10:18:09 +00:00
|
|
|
|
2001-09-13 21:16:25 +00:00
|
|
|
const gchar *g_log_domain_gstreamer = "GStreamer";
|
|
|
|
|
|
|
|
static void
|
2004-03-13 15:27:01 +00:00
|
|
|
debug_log_handler (const gchar * log_domain,
|
|
|
|
GLogLevelFlags log_level, const gchar * message, gpointer user_data)
|
2001-09-13 21:16:25 +00:00
|
|
|
{
|
2002-11-27 21:08:06 +00:00
|
|
|
g_log_default_handler (log_domain, log_level, message, user_data);
|
2002-12-16 09:50:40 +00:00
|
|
|
/* FIXME: do we still need this ? fatal errors these days are all
|
|
|
|
* other than core errors */
|
|
|
|
/* g_on_error_query (NULL); */
|
2001-09-13 21:16:25 +00:00
|
|
|
}
|
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
ARG_VERSION = 1,
|
2002-06-16 19:08:21 +00:00
|
|
|
ARG_FATAL_WARNINGS,
|
2003-12-24 14:36:03 +00:00
|
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
2003-06-29 14:05:49 +00:00
|
|
|
ARG_DEBUG_LEVEL,
|
|
|
|
ARG_DEBUG,
|
|
|
|
ARG_DEBUG_DISABLE,
|
|
|
|
ARG_DEBUG_NO_COLOR,
|
|
|
|
ARG_DEBUG_HELP,
|
2003-11-18 15:31:30 +00:00
|
|
|
#endif
|
2003-05-31 02:04:59 +00:00
|
|
|
ARG_DISABLE_CPU_OPT,
|
2002-02-15 16:14:21 +00:00
|
|
|
ARG_PLUGIN_SPEW,
|
|
|
|
ARG_PLUGIN_PATH,
|
|
|
|
ARG_PLUGIN_LOAD,
|
2003-12-16 12:20:54 +00:00
|
|
|
ARG_SEGTRAP_DISABLE,
|
2002-04-12 09:53:00 +00:00
|
|
|
ARG_SCHEDULER,
|
|
|
|
ARG_REGISTRY
|
2002-02-15 16:14:21 +00:00
|
|
|
};
|
|
|
|
|
2004-06-03 16:50:50 +00:00
|
|
|
static void
|
|
|
|
parse_debug_list (const gchar * list)
|
|
|
|
{
|
|
|
|
gchar **split;
|
|
|
|
gchar **walk;
|
|
|
|
|
|
|
|
g_return_if_fail (list != NULL);
|
|
|
|
|
|
|
|
walk = split = g_strsplit (list, ",", 0);
|
|
|
|
|
|
|
|
while (walk[0]) {
|
|
|
|
gchar **values = g_strsplit (walk[0], ":", 2);
|
|
|
|
|
|
|
|
if (values[0] && values[1]) {
|
|
|
|
gint level = 0;
|
|
|
|
|
|
|
|
g_strstrip (values[0]);
|
|
|
|
g_strstrip (values[1]);
|
|
|
|
level = strtol (values[1], NULL, 0);
|
|
|
|
if (level >= 0 && level < GST_LEVEL_COUNT) {
|
|
|
|
GST_DEBUG ("setting debugging to level %d for name \"%s\"",
|
|
|
|
level, values[0]);
|
|
|
|
gst_debug_set_threshold_for_name (values[0], level);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_strfreev (values);
|
|
|
|
walk++;
|
|
|
|
}
|
|
|
|
g_strfreev (split);
|
|
|
|
}
|
|
|
|
|
2002-02-15 16:14:21 +00:00
|
|
|
#ifndef NUL
|
|
|
|
#define NUL '\0'
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_init_get_popt_table:
|
|
|
|
*
|
|
|
|
* Returns a popt option table with GStreamer's argument specifications. The
|
|
|
|
* table is set up to use popt's callback method, so whenever the parsing is
|
2003-12-24 14:36:03 +00:00
|
|
|
* actually performed (via poptGetContext), the GStreamer libraries will
|
2002-02-15 16:14:21 +00:00
|
|
|
* be initialized.
|
|
|
|
*
|
2004-02-03 14:59:32 +00:00
|
|
|
* This function is useful if you want to integrate GStreamer with other
|
|
|
|
* libraries that use popt.
|
|
|
|
*
|
2002-11-27 21:08:06 +00:00
|
|
|
* Returns: a pointer to the static GStreamer option table.
|
|
|
|
* No free is necessary.
|
2002-02-15 16:14:21 +00:00
|
|
|
*/
|
2004-02-03 14:59:32 +00:00
|
|
|
const GstPoptOption *
|
2002-02-15 16:14:21 +00:00
|
|
|
gst_init_get_popt_table (void)
|
|
|
|
{
|
2004-03-17 02:43:55 +00:00
|
|
|
static GstPoptOption gstreamer_options[] = {
|
|
|
|
{NULL, NUL, POPT_ARG_CALLBACK | POPT_CBFLAG_PRE | POPT_CBFLAG_POST,
|
|
|
|
(void *) &init_popt_callback, 0, NULL, NULL},
|
|
|
|
/* make sure we use our GETTEXT_PACKAGE as the domain for popt translations */
|
|
|
|
{NULL, NUL, POPT_ARG_INTL_DOMAIN, GETTEXT_PACKAGE, 0, NULL, NULL},
|
|
|
|
{"gst-version", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL, ARG_VERSION,
|
|
|
|
N_("Print the GStreamer version"), NULL},
|
|
|
|
{"gst-fatal-warnings", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_FATAL_WARNINGS, N_("Make all warnings fatal"), NULL},
|
|
|
|
|
|
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
|
|
{"gst-debug-help", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_DEBUG_HELP, N_("Print available debug categories and exit"), NULL},
|
|
|
|
{"gst-debug-level", NUL, POPT_ARG_INT | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_DEBUG_LEVEL,
|
|
|
|
N_("Default debug level from 1 (only error) to 5 (anything) or "
|
|
|
|
"0 for no output"),
|
|
|
|
N_("LEVEL")},
|
|
|
|
{"gst-debug", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL, ARG_DEBUG,
|
|
|
|
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", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_DEBUG_NO_COLOR, N_("Disable colored debugging output"), NULL},
|
|
|
|
{"gst-debug-disable", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_DEBUG_DISABLE, N_("Disable debugging")},
|
|
|
|
#endif
|
|
|
|
|
|
|
|
{"gst-disable-cpu-opt", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_DISABLE_CPU_OPT, N_("Disable accelerated CPU instructions"), NULL},
|
|
|
|
{"gst-plugin-spew", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_PLUGIN_SPEW, N_("Enable verbose plugin loading diagnostics"), NULL},
|
|
|
|
{"gst-plugin-path", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_PLUGIN_PATH, NULL, N_("PATHS")},
|
|
|
|
{"gst-plugin-load", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_PLUGIN_LOAD,
|
|
|
|
N_("Comma-separated list of plugins to preload in addition to the "
|
2004-03-26 03:46:16 +00:00
|
|
|
"list stored in envronment variable GST_PLUGIN_PATH"),
|
2004-03-17 02:43:55 +00:00
|
|
|
N_("PLUGINS")},
|
|
|
|
{"gst-disable-segtrap", NUL, POPT_ARG_NONE | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_SEGTRAP_DISABLE,
|
|
|
|
N_("Disable trapping of segmentation faults during plugin loading"),
|
|
|
|
NULL},
|
|
|
|
{"gst-scheduler", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_SCHEDULER, NULL, N_("SCHEDULER")},
|
|
|
|
{"gst-registry", NUL, POPT_ARG_STRING | POPT_ARGFLAG_STRIP, NULL,
|
|
|
|
ARG_REGISTRY, N_("Registry to use"), N_("REGISTRY")},
|
|
|
|
POPT_TABLEEND
|
|
|
|
};
|
|
|
|
static gboolean inited = FALSE;
|
|
|
|
|
|
|
|
if (!inited) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (gstreamer_options); i++) {
|
|
|
|
if (gstreamer_options[i].longName == NULL) {
|
|
|
|
} else if (strcmp (gstreamer_options[i].longName, "gst-plugin-path") == 0) {
|
|
|
|
gstreamer_options[i].descrip =
|
|
|
|
g_strdup_printf (_
|
|
|
|
("path list for loading plugins (separated by '%s')"),
|
|
|
|
G_SEARCHPATH_SEPARATOR_S);
|
|
|
|
} else if (strcmp (gstreamer_options[i].longName, "gst-scheduler") == 0) {
|
|
|
|
gstreamer_options[i].descrip =
|
|
|
|
g_strdup_printf (_("Scheduler to use (default is '%s')"),
|
|
|
|
GST_SCHEDULER_DEFAULT_NAME);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
inited = TRUE;
|
|
|
|
}
|
|
|
|
|
2003-04-04 16:29:37 +00:00
|
|
|
return gstreamer_options;
|
2002-02-15 16:14:21 +00:00
|
|
|
}
|
|
|
|
|
2002-11-27 21:08:06 +00:00
|
|
|
/**
|
|
|
|
* gst_init_check:
|
|
|
|
* @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 will return %FALSE if GStreamer could not be initialized
|
|
|
|
* for some reason. If you want your program to fail fatally,
|
|
|
|
* use gst_init() instead.
|
2002-12-14 13:02:16 +00:00
|
|
|
*
|
2003-12-24 14:36:03 +00:00
|
|
|
* Returns: %TRUE if GStreamer could be initialized.
|
2002-11-27 21:08:06 +00:00
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_init_check (int *argc, char **argv[])
|
|
|
|
{
|
2003-04-04 16:29:37 +00:00
|
|
|
return gst_init_check_with_popt_table (argc, argv, NULL);
|
2002-11-27 21:08:06 +00:00
|
|
|
}
|
|
|
|
|
2000-01-30 09:03:00 +00:00
|
|
|
/**
|
|
|
|
* gst_init:
|
|
|
|
* @argc: pointer to application's argc
|
|
|
|
* @argv: pointer to application's argv
|
|
|
|
*
|
2000-02-02 06:26:44 +00:00
|
|
|
* Initializes the GStreamer library, setting up internal path lists,
|
|
|
|
* registering built-in elements, and loading standard plugins.
|
2002-11-27 21:08:06 +00:00
|
|
|
*
|
|
|
|
* 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.
|
2004-03-26 03:46:16 +00:00
|
|
|
*
|
|
|
|
* 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.
|
2000-01-30 09:03:00 +00:00
|
|
|
*/
|
2002-11-27 21:08:06 +00:00
|
|
|
void
|
2002-02-24 17:08:07 +00:00
|
|
|
gst_init (int *argc, char **argv[])
|
|
|
|
{
|
2003-04-04 16:29:37 +00:00
|
|
|
gst_init_with_popt_table (argc, argv, NULL);
|
2002-02-24 17:08:07 +00:00
|
|
|
}
|
2002-11-27 21:08:06 +00:00
|
|
|
|
2002-02-24 17:08:07 +00:00
|
|
|
/**
|
|
|
|
* gst_init_with_popt_table:
|
|
|
|
* @argc: pointer to application's argc
|
|
|
|
* @argv: pointer to application's argv
|
|
|
|
* @popt_options: pointer to a popt table to append
|
|
|
|
*
|
2002-11-27 21:08:06 +00:00
|
|
|
* Initializes the GStreamer library, parsing the options,
|
2002-08-11 21:50:37 +00:00
|
|
|
* setting up internal path lists,
|
2002-02-24 17:08:07 +00:00
|
|
|
* registering built-in elements, and loading standard plugins.
|
2002-12-14 13:02:16 +00:00
|
|
|
*
|
2003-04-04 16:29:37 +00:00
|
|
|
* 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_with_popt_table() instead.
|
2002-02-24 17:08:07 +00:00
|
|
|
*/
|
2003-04-04 16:29:37 +00:00
|
|
|
void
|
2002-11-27 21:08:06 +00:00
|
|
|
gst_init_with_popt_table (int *argc, char **argv[],
|
2004-03-13 15:27:01 +00:00
|
|
|
const GstPoptOption * popt_options)
|
2003-04-04 16:29:37 +00:00
|
|
|
{
|
|
|
|
if (!gst_init_check_with_popt_table (argc, argv, popt_options)) {
|
|
|
|
g_print ("Could not initialize GStreamer !\n");
|
|
|
|
exit (1);
|
|
|
|
}
|
|
|
|
}
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2003-04-04 16:29:37 +00:00
|
|
|
/**
|
|
|
|
* gst_init_check_with_popt_table:
|
|
|
|
* @argc: pointer to application's argc
|
|
|
|
* @argv: pointer to application's argv
|
|
|
|
* @popt_options: pointer to a popt table to append
|
|
|
|
*
|
|
|
|
* Initializes the GStreamer library, parsing the options,
|
|
|
|
* setting up internal path lists,
|
|
|
|
* registering built-in elements, and loading standard plugins.
|
|
|
|
*
|
2003-12-24 14:36:03 +00:00
|
|
|
* Returns: %TRUE if GStreamer could be initialized.
|
2003-04-04 16:29:37 +00:00
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
gst_init_check_with_popt_table (int *argc, char **argv[],
|
2004-03-13 15:27:01 +00:00
|
|
|
const GstPoptOption * popt_options)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2002-02-15 16:14:21 +00:00
|
|
|
poptContext context;
|
2003-04-04 17:37:19 +00:00
|
|
|
gint nextopt;
|
2004-02-03 14:59:32 +00:00
|
|
|
GstPoptOption *options;
|
2004-06-03 16:50:50 +00:00
|
|
|
const gchar *gst_debug_env = NULL;
|
|
|
|
|
2004-02-03 14:59:32 +00:00
|
|
|
GstPoptOption options_with[] = {
|
2004-03-13 15:27:01 +00:00
|
|
|
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, poptHelpOptions, 0, "Help options:",
|
2004-03-15 19:27:17 +00:00
|
|
|
NULL},
|
2004-03-17 02:43:55 +00:00
|
|
|
{NULL, NUL, POPT_ARG_INCLUDE_TABLE,
|
|
|
|
(GstPoptOption *) gst_init_get_popt_table (), 0,
|
2004-03-15 19:27:17 +00:00
|
|
|
"GStreamer options:", NULL},
|
2004-03-13 15:27:01 +00:00
|
|
|
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, (GstPoptOption *) popt_options, 0,
|
2004-03-15 19:27:17 +00:00
|
|
|
"Application options:", NULL},
|
2003-04-04 16:29:37 +00:00
|
|
|
POPT_TABLEEND
|
2002-02-24 17:08:07 +00:00
|
|
|
};
|
2004-02-03 14:59:32 +00:00
|
|
|
GstPoptOption options_without[] = {
|
2004-03-13 15:27:01 +00:00
|
|
|
{NULL, NUL, POPT_ARG_INCLUDE_TABLE, poptHelpOptions, 0, "Help options:",
|
2004-03-15 19:27:17 +00:00
|
|
|
NULL},
|
2004-03-17 02:43:55 +00:00
|
|
|
{NULL, NUL, POPT_ARG_INCLUDE_TABLE,
|
|
|
|
(GstPoptOption *) gst_init_get_popt_table (), 0,
|
2004-03-15 19:27:17 +00:00
|
|
|
"GStreamer options:", NULL},
|
2003-04-04 16:29:37 +00:00
|
|
|
POPT_TABLEEND
|
2002-02-24 17:08:07 +00:00
|
|
|
};
|
2002-02-15 16:14:21 +00:00
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
if (gst_initialized) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_DEBUG ("already initialized gst");
|
2002-11-27 21:08:06 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2002-02-16 18:27:04 +00:00
|
|
|
if (!argc || !argv) {
|
|
|
|
if (argc || argv)
|
2002-08-11 21:50:37 +00:00
|
|
|
g_warning ("gst_init: Only one of argc or argv was NULL");
|
2002-11-27 21:08:06 +00:00
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
if (!init_pre ())
|
|
|
|
return FALSE;
|
|
|
|
if (!init_post ())
|
|
|
|
return FALSE;
|
2002-11-27 21:08:06 +00:00
|
|
|
gst_initialized = TRUE;
|
|
|
|
return TRUE;
|
2002-02-16 18:27:04 +00:00
|
|
|
}
|
|
|
|
|
2002-02-24 17:08:07 +00:00
|
|
|
if (popt_options == NULL) {
|
|
|
|
options = options_without;
|
|
|
|
} else {
|
|
|
|
options = options_with;
|
|
|
|
}
|
2004-03-13 15:27:01 +00:00
|
|
|
context = poptGetContext ("GStreamer", *argc, (const char **) *argv,
|
|
|
|
options, 0);
|
2002-11-27 21:08:06 +00:00
|
|
|
|
2004-06-03 16:50:50 +00:00
|
|
|
/* check for GST_DEBUG environment variable */
|
|
|
|
gst_debug_env = g_getenv ("GST_DEBUG");
|
|
|
|
if (gst_debug_env)
|
|
|
|
parse_debug_list (gst_debug_env);
|
|
|
|
|
2004-06-10 11:23:42 +00:00
|
|
|
/* Scan until we reach the end (-1), ignoring errors */
|
|
|
|
while ((nextopt = poptGetNextOpt (context)) != -1) {
|
|
|
|
|
|
|
|
/* If an error occurred and it's not an missing options, throw an error
|
|
|
|
* We don't want to show the "unknown option" message, since it'll
|
|
|
|
* might interfere with the applications own command line parsing
|
|
|
|
*/
|
|
|
|
if (nextopt < 0 && nextopt != POPT_ERROR_BADOPT) {
|
|
|
|
g_print ("Error on option %s: %s.\nRun '%s --help' "
|
|
|
|
"to see a full list of available command line options.\n",
|
|
|
|
poptBadOption (context, 0), poptStrerror (nextopt), (*argv)[0]);
|
|
|
|
|
|
|
|
poptFreeContext (context);
|
2004-03-13 15:27:01 +00:00
|
|
|
return FALSE;
|
2004-06-10 11:23:42 +00:00
|
|
|
}
|
2002-02-15 16:14:21 +00:00
|
|
|
}
|
2002-02-16 03:24:50 +00:00
|
|
|
|
2003-04-04 17:37:19 +00:00
|
|
|
*argc = poptStrippedArgv (context, *argc, *argv);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-04-04 19:52:46 +00:00
|
|
|
poptFreeContext (context);
|
|
|
|
|
2002-11-27 21:08:06 +00:00
|
|
|
return TRUE;
|
2002-02-15 16:14:21 +00:00
|
|
|
}
|
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2003-12-24 14:36:03 +00:00
|
|
|
static void
|
2002-02-15 16:14:21 +00:00
|
|
|
add_path_func (gpointer data, gpointer user_data)
|
|
|
|
{
|
2002-05-08 20:40:48 +00:00
|
|
|
GstRegistry *registry = GST_REGISTRY (user_data);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_INFO ("Adding plugin path: \"%s\"", (gchar *) data);
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_registry_add_path (registry, (gchar *) data);
|
2002-02-15 16:14:21 +00:00
|
|
|
}
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif
|
2002-02-15 16:14:21 +00:00
|
|
|
|
2003-12-24 14:36:03 +00:00
|
|
|
static void
|
2002-02-15 16:14:21 +00:00
|
|
|
prepare_for_load_plugin_func (gpointer data, gpointer user_data)
|
|
|
|
{
|
|
|
|
preload_plugins = g_slist_prepend (preload_plugins, data);
|
|
|
|
}
|
|
|
|
|
2003-12-24 14:36:03 +00:00
|
|
|
static void
|
2002-02-15 16:14:21 +00:00
|
|
|
load_plugin_func (gpointer data, gpointer user_data)
|
|
|
|
{
|
2003-02-10 20:32:32 +00:00
|
|
|
GstPlugin *plugin;
|
|
|
|
const gchar *filename;
|
|
|
|
|
|
|
|
filename = (const gchar *) data;
|
2002-05-08 20:40:48 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
plugin = gst_plugin_load_file (filename, NULL);
|
2003-02-10 20:32:32 +00:00
|
|
|
|
2003-10-31 19:32:47 +00:00
|
|
|
if (plugin) {
|
2003-06-29 14:05:49 +00:00
|
|
|
GST_INFO ("Loaded plugin: \"%s\"", filename);
|
2003-02-10 20:32:32 +00:00
|
|
|
|
|
|
|
gst_registry_pool_add_plugin (plugin);
|
2003-06-29 14:05:49 +00:00
|
|
|
} else {
|
|
|
|
GST_WARNING ("Failed to load plugin: \"%s\"", filename);
|
2003-02-10 20:32:32 +00:00
|
|
|
}
|
2002-02-15 16:14:21 +00:00
|
|
|
|
|
|
|
g_free (data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2004-03-13 15:27:01 +00:00
|
|
|
split_and_iterate (const gchar * stringlist, gchar * separator, GFunc iterator,
|
|
|
|
gpointer user_data)
|
2002-02-15 16:14:21 +00:00
|
|
|
{
|
|
|
|
gchar **strings;
|
|
|
|
gint j = 0;
|
|
|
|
gchar *lastlist = g_strdup (stringlist);
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2002-02-15 16:14:21 +00:00
|
|
|
while (lastlist) {
|
|
|
|
strings = g_strsplit (lastlist, separator, MAX_PATH_SPLIT);
|
|
|
|
g_free (lastlist);
|
|
|
|
lastlist = NULL;
|
2000-08-28 20:20:55 +00:00
|
|
|
|
2002-02-15 16:14:21 +00:00
|
|
|
while (strings[j]) {
|
2002-05-08 20:40:48 +00:00
|
|
|
iterator (strings[j], user_data);
|
2002-02-15 16:14:21 +00:00
|
|
|
if (++j == MAX_PATH_SPLIT) {
|
2004-03-15 19:27:17 +00:00
|
|
|
lastlist = g_strdup (strings[j]);
|
|
|
|
g_strfreev (strings);
|
|
|
|
j = 0;
|
|
|
|
break;
|
2002-02-15 16:14:21 +00:00
|
|
|
}
|
|
|
|
}
|
2001-01-01 03:43:27 +00:00
|
|
|
}
|
2002-02-15 16:14:21 +00:00
|
|
|
}
|
2001-01-01 03:43:27 +00:00
|
|
|
|
2002-11-27 21:08:06 +00:00
|
|
|
/* we have no fail cases yet, but maybe in the future */
|
|
|
|
static gboolean
|
2002-02-16 18:27:04 +00:00
|
|
|
init_pre (void)
|
|
|
|
{
|
2002-08-11 21:50:37 +00:00
|
|
|
g_type_init ();
|
2002-05-08 20:40:48 +00:00
|
|
|
|
2003-07-03 18:34:36 +00:00
|
|
|
if (g_thread_supported ()) {
|
|
|
|
/* somebody already initialized threading */
|
|
|
|
} else {
|
2004-03-26 03:46:16 +00:00
|
|
|
g_thread_init (NULL);
|
2003-07-03 18:34:36 +00:00
|
|
|
}
|
|
|
|
/* we need threading to be enabled right here */
|
2004-03-13 15:27:01 +00:00
|
|
|
_gst_debug_init ();
|
2003-11-22 21:46:07 +00:00
|
|
|
|
|
|
|
#ifdef ENABLE_NLS
|
2004-01-13 11:30:00 +00:00
|
|
|
setlocale (LC_ALL, "");
|
|
|
|
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
|
2003-11-22 21:46:07 +00:00
|
|
|
#endif /* ENABLE_NLS */
|
2003-08-17 22:04:55 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
|
|
|
{
|
|
|
|
const gchar *debug_list;
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
debug_list = g_getenv ("GST_DEBUG");
|
|
|
|
if (debug_list) {
|
|
|
|
parse_debug_list (debug_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
|
|
|
{
|
|
|
|
gchar *user_reg;
|
|
|
|
const gchar *homedir;
|
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
_global_registry =
|
2004-03-15 19:27:17 +00:00
|
|
|
gst_xml_registry_new ("global_registry", GLOBAL_REGISTRY_FILE);
|
2002-05-08 20:40:48 +00:00
|
|
|
|
|
|
|
#ifdef PLUGINS_USE_BUILDDIR
|
2003-02-10 20:32:32 +00:00
|
|
|
/* location libgstelements.so */
|
|
|
|
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/libs/gst");
|
|
|
|
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/gst/elements");
|
|
|
|
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/gst/types");
|
|
|
|
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/gst/autoplug");
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_registry_add_path (_global_registry,
|
2004-03-15 19:27:17 +00:00
|
|
|
PLUGINS_BUILDDIR "/gst/schedulers");
|
2003-02-10 20:32:32 +00:00
|
|
|
gst_registry_add_path (_global_registry, PLUGINS_BUILDDIR "/gst/indexers");
|
2002-05-08 20:40:48 +00:00
|
|
|
#else
|
2003-02-10 20:32:32 +00:00
|
|
|
/* add the main (installed) library path */
|
|
|
|
gst_registry_add_path (_global_registry, PLUGINS_DIR);
|
2002-05-08 20:40:48 +00:00
|
|
|
#endif /* PLUGINS_USE_BUILDDIR */
|
|
|
|
|
2004-03-13 15:27:01 +00:00
|
|
|
if (g_getenv ("GST_REGISTRY")) {
|
2003-05-18 22:59:51 +00:00
|
|
|
user_reg = g_strdup (g_getenv ("GST_REGISTRY"));
|
2004-03-13 15:27:01 +00:00
|
|
|
} else {
|
2003-05-18 22:59:51 +00:00
|
|
|
homedir = g_get_home_dir ();
|
|
|
|
user_reg = g_strjoin ("/", homedir, LOCAL_REGISTRY_FILE, NULL);
|
|
|
|
}
|
2003-02-10 20:32:32 +00:00
|
|
|
_user_registry = gst_xml_registry_new ("user_registry", user_reg);
|
|
|
|
|
|
|
|
g_free (user_reg);
|
2002-08-11 21:50:37 +00:00
|
|
|
}
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_REGISTRY */
|
2002-11-27 21:08:06 +00:00
|
|
|
|
|
|
|
return TRUE;
|
2002-05-08 20:40:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_register_core_elements (GstPlugin * plugin)
|
2002-05-08 20:40:48 +00:00
|
|
|
{
|
|
|
|
/* register some standard builtin types */
|
2004-08-03 12:40:47 +00:00
|
|
|
if (!gst_element_register (plugin, "bin", GST_RANK_PRIMARY,
|
|
|
|
GST_TYPE_BIN) ||
|
|
|
|
!gst_element_register (plugin, "pipeline", GST_RANK_PRIMARY,
|
|
|
|
GST_TYPE_PIPELINE) ||
|
|
|
|
!gst_element_register (plugin, "thread", GST_RANK_PRIMARY,
|
|
|
|
GST_TYPE_THREAD) ||
|
|
|
|
!gst_element_register (plugin, "queue", GST_RANK_PRIMARY, GST_TYPE_QUEUE))
|
|
|
|
g_assert_not_reached ();
|
2002-05-08 20:40:48 +00:00
|
|
|
|
|
|
|
return TRUE;
|
2002-02-16 18:27:04 +00:00
|
|
|
}
|
|
|
|
|
2002-05-08 20:40:48 +00:00
|
|
|
static GstPluginDesc plugin_desc = {
|
2003-12-24 14:36:03 +00:00
|
|
|
GST_VERSION_MAJOR,
|
|
|
|
GST_VERSION_MINOR,
|
2004-02-10 10:30:24 +00:00
|
|
|
"gstcoreelements",
|
2003-10-31 19:32:47 +00:00
|
|
|
"core elements of the GStreamer library",
|
|
|
|
gst_register_core_elements,
|
|
|
|
NULL,
|
|
|
|
VERSION,
|
|
|
|
GST_LICENSE,
|
|
|
|
GST_PACKAGE,
|
|
|
|
GST_ORIGIN,
|
|
|
|
|
2003-12-09 02:39:31 +00:00
|
|
|
GST_PADDING_INIT
|
2003-12-24 14:36:03 +00:00
|
|
|
};
|
2002-05-08 20:40:48 +00:00
|
|
|
|
2002-08-11 21:50:37 +00:00
|
|
|
/*
|
|
|
|
* this bit handles:
|
|
|
|
* - initalization of threads if we use them
|
|
|
|
* - log handler
|
|
|
|
* - initial output
|
|
|
|
* - initializes gst_format
|
|
|
|
* - registers a bunch of types for gst_objects
|
2002-11-27 21:08:06 +00:00
|
|
|
*
|
|
|
|
* - we don't have cases yet where this fails, but in the future
|
|
|
|
* we might and then it's nice to be able to return that
|
2002-08-11 21:50:37 +00:00
|
|
|
*/
|
2002-11-27 21:08:06 +00:00
|
|
|
static gboolean
|
2002-02-15 16:14:21 +00:00
|
|
|
init_post (void)
|
|
|
|
{
|
|
|
|
GLogLevelFlags llf;
|
2002-02-20 21:31:16 +00:00
|
|
|
const gchar *plugin_path;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2002-02-15 16:14:21 +00:00
|
|
|
#ifndef GST_DISABLE_TRACE
|
|
|
|
GstTrace *gst_trace;
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_TRACE */
|
2002-06-21 14:50:00 +00:00
|
|
|
|
2001-09-13 21:16:25 +00:00
|
|
|
llf = G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR | G_LOG_FLAG_FATAL;
|
2002-08-11 21:50:37 +00:00
|
|
|
g_log_set_handler (g_log_domain_gstreamer, llf, debug_log_handler, NULL);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2004-03-26 03:46:16 +00:00
|
|
|
GST_INFO ("Initializing GStreamer Core Library version %s", VERSION);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2002-07-28 01:54:42 +00:00
|
|
|
_gst_format_initialize ();
|
2003-01-01 03:09:39 +00:00
|
|
|
_gst_query_type_initialize ();
|
2001-10-17 10:21:27 +00:00
|
|
|
gst_object_get_type ();
|
|
|
|
gst_pad_get_type ();
|
|
|
|
gst_real_pad_get_type ();
|
|
|
|
gst_ghost_pad_get_type ();
|
2002-04-11 20:35:18 +00:00
|
|
|
gst_element_factory_get_type ();
|
2001-10-17 10:21:27 +00:00
|
|
|
gst_element_get_type ();
|
2002-04-11 20:35:18 +00:00
|
|
|
gst_scheduler_factory_get_type ();
|
2003-10-28 20:25:30 +00:00
|
|
|
gst_type_find_factory_get_type ();
|
2001-10-21 18:00:31 +00:00
|
|
|
gst_bin_get_type ();
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_INDEX
|
2002-12-12 22:14:36 +00:00
|
|
|
gst_index_factory_get_type ();
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_INDEX */
|
|
|
|
#ifndef GST_DISABLE_URI
|
2003-01-16 21:22:06 +00:00
|
|
|
gst_uri_handler_get_type ();
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_URI */
|
2002-05-08 20:40:48 +00:00
|
|
|
|
2002-08-11 21:50:37 +00:00
|
|
|
plugin_path = g_getenv ("GST_PLUGIN_PATH");
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2004-03-13 15:27:01 +00:00
|
|
|
split_and_iterate (plugin_path, G_SEARCHPATH_SEPARATOR_S, add_path_func,
|
|
|
|
_global_registry);
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_REGISTRY */
|
2002-05-08 20:40:48 +00:00
|
|
|
|
|
|
|
/* register core plugins */
|
|
|
|
_gst_plugin_register_static (&plugin_desc);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-05-31 02:04:59 +00:00
|
|
|
_gst_cpu_initialize (_gst_enable_cpu_opt);
|
2004-03-12 19:35:40 +00:00
|
|
|
gst_structure_get_type ();
|
2003-11-03 09:10:07 +00:00
|
|
|
_gst_value_initialize ();
|
2004-03-12 19:32:26 +00:00
|
|
|
gst_caps_get_type ();
|
2000-11-04 18:54:07 +00:00
|
|
|
_gst_plugin_initialize ();
|
2001-10-17 10:21:27 +00:00
|
|
|
_gst_event_initialize ();
|
2000-11-04 18:54:07 +00:00
|
|
|
_gst_buffer_initialize ();
|
2003-11-24 02:09:23 +00:00
|
|
|
_gst_tag_initialize ();
|
2000-01-30 09:03:00 +00:00
|
|
|
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2002-05-11 20:30:05 +00:00
|
|
|
if (!_gst_registry_fixed) {
|
|
|
|
/* don't override command-line options */
|
|
|
|
if (g_getenv ("GST_REGISTRY")) {
|
2004-03-13 15:27:01 +00:00
|
|
|
g_object_set (_global_registry, "location", g_getenv ("GST_REGISTRY"),
|
2004-03-15 19:27:17 +00:00
|
|
|
NULL);
|
2002-05-11 20:30:05 +00:00
|
|
|
_gst_registry_fixed = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!_gst_registry_fixed) {
|
|
|
|
gst_registry_pool_add (_global_registry, 100);
|
|
|
|
gst_registry_pool_add (_user_registry, 50);
|
|
|
|
} else {
|
2004-06-10 11:23:42 +00:00
|
|
|
|
2004-03-01 23:38:27 +00:00
|
|
|
gst_registry_pool_add (_global_registry, 100);
|
2002-05-11 20:30:05 +00:00
|
|
|
}
|
|
|
|
|
2002-05-08 20:40:48 +00:00
|
|
|
if (_gst_registry_auto_load) {
|
|
|
|
gst_registry_pool_load_all ();
|
|
|
|
}
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_REGISTRY */
|
2002-05-08 20:40:48 +00:00
|
|
|
|
2001-10-17 10:21:27 +00:00
|
|
|
/* if we need to preload plugins */
|
|
|
|
if (preload_plugins) {
|
|
|
|
g_slist_foreach (preload_plugins, load_plugin_func, NULL);
|
|
|
|
g_slist_free (preload_plugins);
|
|
|
|
preload_plugins = NULL;
|
|
|
|
}
|
2001-06-25 20:36:02 +00:00
|
|
|
#ifndef GST_DISABLE_TRACE
|
2000-01-30 09:03:00 +00:00
|
|
|
_gst_trace_on = 0;
|
|
|
|
if (_gst_trace_on) {
|
2002-08-12 16:59:39 +00:00
|
|
|
gst_trace = gst_trace_new ("gst.trace", 1024);
|
2000-11-04 18:54:07 +00:00
|
|
|
gst_trace_set_default (gst_trace);
|
2000-01-30 09:03:00 +00:00
|
|
|
}
|
2001-12-14 22:59:21 +00:00
|
|
|
#endif /* GST_DISABLE_TRACE */
|
2002-11-27 21:08:06 +00:00
|
|
|
|
|
|
|
return TRUE;
|
2002-04-07 23:32:16 +00:00
|
|
|
}
|
2001-03-09 12:31:07 +00:00
|
|
|
|
2003-11-18 15:31:30 +00:00
|
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
|
|
static gint
|
|
|
|
sort_by_category_name (gconstpointer a, gconstpointer b)
|
|
|
|
{
|
|
|
|
return strcmp (gst_debug_category_get_name ((GstDebugCategory *) a),
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_debug_category_get_name ((GstDebugCategory *) b));
|
2003-11-18 15:31:30 +00:00
|
|
|
}
|
2002-04-07 23:32:16 +00:00
|
|
|
static void
|
2003-12-24 14:36:03 +00:00
|
|
|
gst_debug_help (void)
|
2002-04-07 23:32:16 +00:00
|
|
|
{
|
2003-11-18 15:31:30 +00:00
|
|
|
GSList *list, *walk;
|
|
|
|
GList *list2, *walk2;
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-11-18 15:31:30 +00:00
|
|
|
if (!init_post ())
|
|
|
|
exit (1);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-11-18 15:31:30 +00:00
|
|
|
walk2 = list2 = gst_registry_pool_plugin_list ();
|
|
|
|
while (walk2) {
|
|
|
|
GstPlugin *plugin = GST_PLUGIN (walk2->data);
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2003-11-18 15:31:30 +00:00
|
|
|
walk2 = g_list_next (walk2);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-11-18 15:31:30 +00:00
|
|
|
if (!gst_plugin_is_loaded (plugin)) {
|
2003-12-24 14:36:03 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2003-11-18 15:31:30 +00:00
|
|
|
if (GST_IS_REGISTRY (plugin->manager)) {
|
2004-03-15 19:27:17 +00:00
|
|
|
GST_CAT_LOG (GST_CAT_PLUGIN_LOADING, "loading plugin %s",
|
|
|
|
plugin->desc.name);
|
|
|
|
if (gst_registry_load_plugin (GST_REGISTRY (plugin->manager),
|
|
|
|
plugin) != GST_REGISTRY_OK)
|
|
|
|
GST_CAT_WARNING (GST_CAT_PLUGIN_LOADING, "loading plugin %s failed",
|
|
|
|
plugin->desc.name);
|
2003-11-18 15:31:30 +00:00
|
|
|
}
|
|
|
|
#endif /* GST_DISABLE_REGISTRY */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_list_free (list2);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-11-18 15:31:30 +00:00
|
|
|
list = gst_debug_get_all_categories ();
|
|
|
|
walk = list = g_slist_sort (list, sort_by_category_name);
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
g_print ("\n");
|
|
|
|
g_print ("name level description\n");
|
|
|
|
g_print ("---------------------+--------+--------------------------------\n");
|
|
|
|
|
|
|
|
while (walk) {
|
2003-11-18 15:31:30 +00:00
|
|
|
GstDebugCategory *cat = (GstDebugCategory *) walk->data;
|
2003-12-24 14:36:03 +00:00
|
|
|
|
2003-06-29 14:05:49 +00:00
|
|
|
if (gst_debug_is_colored ()) {
|
|
|
|
gchar *color = gst_debug_construct_term_color (cat->color);
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2003-12-24 14:36:03 +00:00
|
|
|
g_print ("%s%-20s\033[00m %1d %s %s%s\033[00m\n",
|
2004-03-15 19:27:17 +00:00
|
|
|
color,
|
|
|
|
gst_debug_category_get_name (cat),
|
|
|
|
gst_debug_category_get_threshold (cat),
|
|
|
|
gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
|
|
|
|
color, gst_debug_category_get_description (cat));
|
2003-06-29 14:05:49 +00:00
|
|
|
g_free (color);
|
|
|
|
} else {
|
2003-12-24 14:36:03 +00:00
|
|
|
g_print ("%-20s %1d %s %s\n", gst_debug_category_get_name (cat),
|
2004-03-15 19:27:17 +00:00
|
|
|
gst_debug_category_get_threshold (cat),
|
|
|
|
gst_debug_level_get_name (gst_debug_category_get_threshold (cat)),
|
|
|
|
gst_debug_category_get_description (cat));
|
2001-01-01 03:43:27 +00:00
|
|
|
}
|
2003-06-29 14:05:49 +00:00
|
|
|
walk = g_slist_next (walk);
|
2003-12-24 14:36:03 +00:00
|
|
|
}
|
2003-11-18 15:31:30 +00:00
|
|
|
g_slist_free (list);
|
2003-06-29 14:05:49 +00:00
|
|
|
g_print ("\n");
|
2002-02-15 16:14:21 +00:00
|
|
|
}
|
2003-12-24 14:36:03 +00:00
|
|
|
#endif
|
2001-01-01 03:43:27 +00:00
|
|
|
|
2002-02-15 16:14:21 +00:00
|
|
|
static void
|
|
|
|
init_popt_callback (poptContext context, enum poptCallbackReason reason,
|
2004-03-13 15:27:01 +00:00
|
|
|
const GstPoptOption * option, const char *arg, void *data)
|
2002-02-15 16:14:21 +00:00
|
|
|
{
|
2002-04-16 13:47:50 +00:00
|
|
|
GLogLevelFlags fatal_mask;
|
2002-02-15 16:14:21 +00:00
|
|
|
|
2002-11-27 21:08:06 +00:00
|
|
|
if (gst_initialized)
|
|
|
|
return;
|
2002-02-15 16:14:21 +00:00
|
|
|
switch (reason) {
|
2004-03-13 15:27:01 +00:00
|
|
|
case POPT_CALLBACK_REASON_PRE:
|
|
|
|
if (!init_pre ())
|
2004-03-15 19:27:17 +00:00
|
|
|
_gst_initialization_failure = TRUE;
|
2002-04-16 13:47:50 +00:00
|
|
|
break;
|
2004-03-13 15:27:01 +00:00
|
|
|
case POPT_CALLBACK_REASON_OPTION:
|
|
|
|
switch (option->val) {
|
2004-03-15 19:27:17 +00:00
|
|
|
case ARG_VERSION:
|
|
|
|
g_print ("GStreamer Core Library version %s\n", GST_VERSION);
|
|
|
|
exit (0);
|
|
|
|
case ARG_FATAL_WARNINGS:
|
|
|
|
fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
|
|
|
|
fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
|
|
|
|
g_log_set_always_fatal (fatal_mask);
|
|
|
|
break;
|
2003-12-24 14:36:03 +00:00
|
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
2004-03-15 19:27:17 +00:00
|
|
|
case ARG_DEBUG_LEVEL:{
|
|
|
|
gint tmp = 0;
|
|
|
|
|
|
|
|
tmp = strtol (arg, NULL, 0);
|
|
|
|
if (tmp >= 0 && tmp < GST_LEVEL_COUNT) {
|
|
|
|
gst_debug_set_default_threshold (tmp);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ARG_DEBUG:
|
|
|
|
parse_debug_list (arg);
|
|
|
|
break;
|
|
|
|
case ARG_DEBUG_NO_COLOR:
|
|
|
|
gst_debug_set_colored (FALSE);
|
|
|
|
break;
|
|
|
|
case ARG_DEBUG_DISABLE:
|
|
|
|
gst_debug_set_active (FALSE);
|
|
|
|
break;
|
|
|
|
case ARG_DEBUG_HELP:
|
|
|
|
gst_debug_help ();
|
|
|
|
exit (0);
|
2003-11-18 15:31:30 +00:00
|
|
|
#endif
|
2004-03-15 19:27:17 +00:00
|
|
|
case ARG_DISABLE_CPU_OPT:
|
|
|
|
_gst_enable_cpu_opt = FALSE;
|
|
|
|
break;
|
|
|
|
case ARG_PLUGIN_SPEW:
|
|
|
|
break;
|
|
|
|
case ARG_PLUGIN_PATH:
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2004-03-15 19:27:17 +00:00
|
|
|
split_and_iterate (arg, G_SEARCHPATH_SEPARATOR_S, add_path_func,
|
|
|
|
_user_registry);
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_REGISTRY */
|
2004-03-15 19:27:17 +00:00
|
|
|
break;
|
|
|
|
case ARG_PLUGIN_LOAD:
|
|
|
|
split_and_iterate (arg, ",", prepare_for_load_plugin_func, NULL);
|
|
|
|
break;
|
|
|
|
case ARG_SEGTRAP_DISABLE:
|
|
|
|
_gst_disable_segtrap = TRUE;
|
|
|
|
break;
|
|
|
|
case ARG_SCHEDULER:
|
|
|
|
gst_scheduler_factory_set_default_name (arg);
|
|
|
|
break;
|
|
|
|
case ARG_REGISTRY:
|
2003-02-10 20:32:32 +00:00
|
|
|
#ifndef GST_DISABLE_REGISTRY
|
2004-03-15 19:27:17 +00:00
|
|
|
g_object_set (G_OBJECT (_user_registry), "location", arg, NULL);
|
|
|
|
_gst_registry_fixed = TRUE;
|
2003-02-10 20:32:32 +00:00
|
|
|
#endif /* GST_DISABLE_REGISTRY */
|
2004-03-15 19:27:17 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_warning ("option %d not recognized", option->val);
|
|
|
|
break;
|
2004-03-13 15:27:01 +00:00
|
|
|
}
|
2002-04-12 09:53:00 +00:00
|
|
|
break;
|
2004-03-13 15:27:01 +00:00
|
|
|
case POPT_CALLBACK_REASON_POST:
|
|
|
|
if (!init_post ())
|
2004-03-15 19:27:17 +00:00
|
|
|
_gst_initialization_failure = TRUE;
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_initialized = TRUE;
|
2002-02-15 16:14:21 +00:00
|
|
|
break;
|
|
|
|
}
|
2001-01-01 03:43:27 +00:00
|
|
|
}
|
|
|
|
|
2002-07-13 23:05:46 +00:00
|
|
|
/**
|
|
|
|
* gst_use_threads:
|
2003-12-24 14:36:03 +00:00
|
|
|
* @use_threads: a #gboolean indicating whether threads should be used
|
2002-07-13 23:05:46 +00:00
|
|
|
*
|
2004-03-26 03:46:16 +00:00
|
|
|
* This function is deprecated and should not be used in new code.
|
|
|
|
* GStreamer requires threads to be enabled at all times.
|
2002-07-13 23:05:46 +00:00
|
|
|
*/
|
2002-06-23 12:42:52 +00:00
|
|
|
void
|
|
|
|
gst_use_threads (gboolean use_threads)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2002-07-13 23:05:46 +00:00
|
|
|
/**
|
|
|
|
* gst_has_threads:
|
|
|
|
*
|
2004-03-26 03:46:16 +00:00
|
|
|
* This function is deprecated and should not be used in new code.
|
|
|
|
*
|
2003-12-24 14:36:03 +00:00
|
|
|
* Queries if GStreamer has threads enabled.
|
|
|
|
*
|
|
|
|
* Returns: %TRUE if threads are enabled.
|
2002-07-13 23:05:46 +00:00
|
|
|
*/
|
2002-06-21 14:50:00 +00:00
|
|
|
gboolean
|
2002-06-23 12:42:52 +00:00
|
|
|
gst_has_threads (void)
|
2002-06-21 14:50:00 +00:00
|
|
|
{
|
2004-03-26 03:46:16 +00:00
|
|
|
return TRUE;
|
2002-06-21 14:50:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-12-14 18:11:52 +00:00
|
|
|
static GSList *mainloops = NULL;
|
|
|
|
|
2000-09-14 20:31:03 +00:00
|
|
|
/**
|
|
|
|
* gst_main:
|
|
|
|
*
|
2003-12-24 14:36:03 +00:00
|
|
|
* Enters the main GStreamer processing loop.
|
2004-03-26 03:46:16 +00:00
|
|
|
*
|
|
|
|
* This function duplicates functionality in glib, and will be removed
|
|
|
|
* during the 0.9 development series.
|
2000-09-14 20:31:03 +00:00
|
|
|
*/
|
2003-12-24 14:36:03 +00:00
|
|
|
void
|
|
|
|
gst_main (void)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-12-14 18:11:52 +00:00
|
|
|
GMainLoop *loop;
|
|
|
|
|
|
|
|
loop = g_main_loop_new (NULL, FALSE);
|
|
|
|
mainloops = g_slist_prepend (mainloops, loop);
|
|
|
|
|
|
|
|
g_main_loop_run (loop);
|
2000-09-09 16:36:10 +00:00
|
|
|
}
|
|
|
|
|
2000-09-14 20:31:03 +00:00
|
|
|
/**
|
|
|
|
* gst_main_quit:
|
|
|
|
*
|
2003-12-24 14:36:03 +00:00
|
|
|
* Exits the main GStreamer processing loop.
|
2004-03-26 03:46:16 +00:00
|
|
|
*
|
|
|
|
* This function duplicates functionality in glib, and will be removed
|
|
|
|
* during the 0.9 development series.
|
2000-09-14 20:31:03 +00:00
|
|
|
*/
|
2003-12-24 14:36:03 +00:00
|
|
|
void
|
|
|
|
gst_main_quit (void)
|
2000-11-04 18:54:07 +00:00
|
|
|
{
|
2001-12-14 18:11:52 +00:00
|
|
|
if (!mainloops)
|
2002-10-27 01:35:51 +00:00
|
|
|
g_error ("Quit more loops than there are");
|
2001-12-14 18:11:52 +00:00
|
|
|
else {
|
|
|
|
GMainLoop *loop = mainloops->data;
|
2004-03-13 15:27:01 +00:00
|
|
|
|
2001-12-14 18:11:52 +00:00
|
|
|
mainloops = g_slist_delete_link (mainloops, mainloops);
|
|
|
|
g_main_loop_quit (loop);
|
2002-09-15 13:45:26 +00:00
|
|
|
g_main_loop_unref (loop);
|
2001-12-14 18:11:52 +00:00
|
|
|
}
|
2000-09-09 16:36:10 +00:00
|
|
|
}
|
2001-10-17 10:21:27 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gst_version:
|
|
|
|
* @major: pointer to a guint to store the major version number
|
|
|
|
* @minor: pointer to a guint to store the minor version number
|
|
|
|
* @micro: pointer to a guint to store the micro version number
|
|
|
|
*
|
2003-12-24 14:36:03 +00:00
|
|
|
* Gets the version number of the GStreamer library.
|
2001-10-17 10:21:27 +00:00
|
|
|
*/
|
2003-12-24 14:36:03 +00:00
|
|
|
void
|
2004-03-13 15:27:01 +00:00
|
|
|
gst_version (guint * major, guint * minor, guint * micro)
|
2001-10-17 10:21:27 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (major);
|
|
|
|
g_return_if_fail (minor);
|
|
|
|
g_return_if_fail (micro);
|
|
|
|
|
|
|
|
*major = GST_VERSION_MAJOR;
|
|
|
|
*minor = GST_VERSION_MINOR;
|
|
|
|
*micro = GST_VERSION_MICRO;
|
|
|
|
}
|