mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-24 18:51:11 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/registries/gstxmlregistry.c
Thomas Vander Stichele 34359ad6d7 respect order of plugin dirs when loading pllugins and rebuilding registry 
Original commit message from CVS:
respect order of plugin dirs when loading pllugins and rebuilding registry
2005-08-25 20:52:07 +00:00

1446 lines
41 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
* 2000 Wim Taymans <wtay@chello.be>
*
* gstxml_registry.c: GstXMLRegistry object, support routines
*
* 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.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#ifdef _MSC_VER
#include <sys/utime.h>
#include <io.h>
#ifndef F_OK
#define F_OK 0
#define W_OK 2
#define R_OK 4
#endif
#ifndef S_ISREG
#define S_ISREG(mode) ((mode)&_S_IFREG)
#endif
#ifndef S_ISDIR
#define S_ISDIR(mode) ((mode)&_S_IFDIR)
#endif
#else /* _MSC_VER */
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <utime.h>
#endif
#include <gst/gst_private.h>
#include <gst/gstelement.h>
#include <gst/gsttypefind.h>
#include <gst/gsturi.h>
#include <gst/gstinfo.h>
#include "gstxmlregistry.h"
#define BLOCK_SIZE 1024*10
#define CLASS(registry) GST_XML_REGISTRY_CLASS (G_OBJECT_GET_CLASS (registry))
enum
{
PROP_0,
PROP_LOCATION
};
static void gst_xml_registry_class_init (GstXMLRegistryClass * klass);
static void gst_xml_registry_init (GstXMLRegistry * registry);
static void gst_xml_registry_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_xml_registry_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static gboolean gst_xml_registry_load (GstRegistry * registry);
static gboolean gst_xml_registry_save (GstRegistry * registry);
static gboolean gst_xml_registry_rebuild (GstRegistry * registry);
static void gst_xml_registry_get_perms_func (GstXMLRegistry * registry);
static void gst_xml_registry_add_path_list_func (GstXMLRegistry * registry);
static gboolean gst_xml_registry_open_func (GstXMLRegistry * registry,
GstXMLRegistryMode mode);
static gboolean gst_xml_registry_load_func (GstXMLRegistry * registry,
gchar * data, gssize * size);
static gboolean gst_xml_registry_save_func (GstXMLRegistry * registry,
gchar * format, ...);
static gboolean gst_xml_registry_close_func (GstXMLRegistry * registry);
static GstRegistryReturn gst_xml_registry_load_plugin (GstRegistry * registry,
GstPlugin * plugin);
static void gst_xml_registry_start_element (GMarkupParseContext * context,
const gchar * element_name,
const gchar ** attribute_names,
const gchar ** attribute_values, gpointer user_data, GError ** error);
static void gst_xml_registry_end_element (GMarkupParseContext * context,
const gchar * element_name, gpointer user_data, GError ** error);
static void gst_xml_registry_text (GMarkupParseContext * context,
const gchar * text, gsize text_len, gpointer user_data, GError ** error);
static void gst_xml_registry_passthrough (GMarkupParseContext * context,
const gchar * passthrough_text,
gsize text_len, gpointer user_data, GError ** error);
static void gst_xml_registry_error (GMarkupParseContext * context,
GError * error, gpointer user_data);
static void gst_xml_registry_paths_start_element (GMarkupParseContext * context,
const gchar * element_name,
const gchar ** attribute_names,
const gchar ** attribute_values, gpointer user_data, GError ** error);
static void gst_xml_registry_paths_end_element (GMarkupParseContext * context,
const gchar * element_name, gpointer user_data, GError ** error);
static void gst_xml_registry_paths_text (GMarkupParseContext * context,
const gchar * text, gsize text_len, gpointer user_data, GError ** error);
static GstRegistryClass *parent_class = NULL;
/* static guint gst_xml_registry_signals[LAST_SIGNAL] = { 0 }; */
static const GMarkupParser gst_xml_registry_parser = {
gst_xml_registry_start_element,
gst_xml_registry_end_element,
gst_xml_registry_text,
gst_xml_registry_passthrough,
gst_xml_registry_error,
};
static const GMarkupParser gst_xml_registry_paths_parser = {
gst_xml_registry_paths_start_element,
gst_xml_registry_paths_end_element,
gst_xml_registry_paths_text,
NULL,
NULL
};
GType
gst_xml_registry_get_type (void)
{
static GType xml_registry_type = 0;
if (!xml_registry_type) {
static const GTypeInfo xml_registry_info = {
sizeof (GstXMLRegistryClass),
NULL,
NULL,
(GClassInitFunc) gst_xml_registry_class_init,
NULL,
NULL,
sizeof (GstXMLRegistry),
0,
(GInstanceInitFunc) gst_xml_registry_init,
NULL
};
xml_registry_type = g_type_register_static (GST_TYPE_REGISTRY,
"GstXMLRegistry", &xml_registry_info, 0);
}
return xml_registry_type;
}
static void
gst_xml_registry_class_init (GstXMLRegistryClass * klass)
{
GObjectClass *gobject_class;
GstRegistryClass *gstregistry_class;
GstXMLRegistryClass *gstxmlregistry_class;
gobject_class = (GObjectClass *) klass;
gstregistry_class = (GstRegistryClass *) klass;
gstxmlregistry_class = (GstXMLRegistryClass *) klass;
parent_class = g_type_class_ref (GST_TYPE_REGISTRY);
gobject_class->get_property =
GST_DEBUG_FUNCPTR (gst_xml_registry_get_property);
gobject_class->set_property =
GST_DEBUG_FUNCPTR (gst_xml_registry_set_property);
g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_LOCATION,
g_param_spec_string ("location", "Location",
"Location of the registry file", NULL, G_PARAM_READWRITE));
gstregistry_class->load = GST_DEBUG_FUNCPTR (gst_xml_registry_load);
gstregistry_class->save = GST_DEBUG_FUNCPTR (gst_xml_registry_save);
gstregistry_class->rebuild = GST_DEBUG_FUNCPTR (gst_xml_registry_rebuild);
gstregistry_class->load_plugin =
GST_DEBUG_FUNCPTR (gst_xml_registry_load_plugin);
gstxmlregistry_class->get_perms_func =
GST_DEBUG_FUNCPTR (gst_xml_registry_get_perms_func);
gstxmlregistry_class->add_path_list_func =
GST_DEBUG_FUNCPTR (gst_xml_registry_add_path_list_func);
gstxmlregistry_class->open_func =
GST_DEBUG_FUNCPTR (gst_xml_registry_open_func);
gstxmlregistry_class->load_func =
GST_DEBUG_FUNCPTR (gst_xml_registry_load_func);
gstxmlregistry_class->save_func =
GST_DEBUG_FUNCPTR (gst_xml_registry_save_func);
gstxmlregistry_class->close_func =
GST_DEBUG_FUNCPTR (gst_xml_registry_close_func);
}
static void
gst_xml_registry_init (GstXMLRegistry * registry)
{
registry->location = NULL;
registry->context = NULL;
registry->state = GST_XML_REGISTRY_NONE;
registry->current_plugin = NULL;
registry->current_feature = NULL;
registry->open_tags = NULL;
}
/**
* gst_xml_registry_new:
* @name: the name of the registry
* @location: the location of the registry file
*
* Create a new xml registry with the given name and location.
*
* Returns: a new GstXMLRegistry with the given name an location.
*/
GstRegistry *
gst_xml_registry_new (const gchar * name, const gchar * location)
{
GstXMLRegistry *xmlregistry;
xmlregistry = GST_XML_REGISTRY (g_object_new (GST_TYPE_XML_REGISTRY, NULL));
g_object_set (G_OBJECT (xmlregistry), "location", location, NULL);
GST_REGISTRY (xmlregistry)->name = g_strdup (name);
return GST_REGISTRY (xmlregistry);
}
static void
gst_xml_registry_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstXMLRegistry *registry;
registry = GST_XML_REGISTRY (object);
switch (prop_id) {
case PROP_LOCATION:
if (registry->open) {
CLASS (object)->close_func (registry);
g_return_if_fail (registry->open == FALSE);
}
if (registry->location)
g_free (registry->location);
registry->location = g_strdup (g_value_get_string (value));
GST_REGISTRY (registry)->flags = 0x0;
if (CLASS (object)->get_perms_func)
CLASS (object)->get_perms_func (registry);
if (CLASS (object)->add_path_list_func)
CLASS (object)->add_path_list_func (registry);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_xml_registry_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstXMLRegistry *registry;
registry = GST_XML_REGISTRY (object);
switch (prop_id) {
case PROP_LOCATION:
g_value_set_string (value, g_strdup (registry->location));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/* this function returns the biggest of the path's mtime and ctime
* mtime is updated through an actual write (data)
* ctime is updated through changing inode information
* so this function returns the last time *anything* changed to this path
* it also sets the given boolean to TRUE if the given path is a directory
*/
static time_t
get_time (const char *path, gboolean * is_dir)
{
struct stat statbuf;
if (stat (path, &statbuf)) {
*is_dir = FALSE;
return 0;
}
if (is_dir)
*is_dir = S_ISDIR (statbuf.st_mode);
if (statbuf.st_mtime > statbuf.st_ctime)
return statbuf.st_mtime;
return statbuf.st_ctime;
}
#if defined(_MSC_VER) || defined(__MINGW32__)
#define xmkdir(dirname) _mkdir (dirname)
#else
#define xmkdir(dirname) mkdir (dirname, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
#endif
static gboolean
make_dir (gchar * filename)
{
struct stat dirstat;
gchar *dirname;
if (strrchr (filename, '/') == NULL)
return FALSE;
dirname = g_strndup (filename, strrchr (filename, '/') - filename);
if (stat (dirname, &dirstat) == -1 && errno == ENOENT) {
if (xmkdir (dirname) != 0) {
if (make_dir (dirname) != TRUE) {
g_free (dirname);
return FALSE;
} else {
if (xmkdir (dirname) != 0) {
return FALSE;
}
}
}
}
g_free (dirname);
return TRUE;
}
static void
gst_xml_registry_get_perms_func (GstXMLRegistry * registry)
{
gchar *dirname;
/* if the dir does not exist, make it. if that can't be done, flags = 0x0.
if the file can be appended to, it's writable. if it can then be read,
it's readable.
After that check if it exists. */
if (make_dir (registry->location) != TRUE) {
/* we can't do anything with it, leave flags as 0x0 */
return;
}
dirname = g_path_get_dirname (registry->location);
if (g_file_test (registry->location, G_FILE_TEST_EXISTS)) {
GST_REGISTRY (registry)->flags |= GST_REGISTRY_EXISTS;
}
if (!access (dirname, W_OK)) {
GST_REGISTRY (registry)->flags |= GST_REGISTRY_WRITABLE;
}
if (!access (dirname, R_OK)) {
GST_REGISTRY (registry)->flags |= GST_REGISTRY_READABLE;
}
g_free (dirname);
}
static void
gst_xml_registry_add_path_list_func (GstXMLRegistry * registry)
{
FILE *reg = NULL;
GMarkupParseContext *context;
gchar *text = NULL;
gssize size;
GError *error = NULL;
context = g_markup_parse_context_new (&gst_xml_registry_paths_parser, 0,
registry, NULL);
if (!(reg = fopen (registry->location, "r"))) {
goto finished;
}
/* slightly allocate more as gmarkup reads too much */
text = g_malloc0 (BLOCK_SIZE + 32);
size = fread (text, 1, BLOCK_SIZE, reg);
while (size) {
g_markup_parse_context_parse (context, text, size, &error);
if (error) {
GST_ERROR ("parsing registry %s: %s\n",
registry->location, error->message);
goto finished;
}
if (registry->state == GST_XML_REGISTRY_PATHS_DONE)
break;
size = fread (text, 1, BLOCK_SIZE, reg);
}
finished:
g_markup_parse_context_free (context);
if (reg)
fclose (reg);
g_free (text);
}
/* return TRUE iff regtime is more recent than the times of all the .so files
* in the plugin dirs; ie return TRUE if this path does not need to trigger
* a rebuild of registry
*
* - if it's a directory, recurse on subdirs
* - if it's a file
* - if entry is not newer, return TRUE.
* - if it's newer
* - and it's a plugin, return FALSE
* - otherwise return TRUE
*/
static gboolean
plugin_times_older_than_recurse (gchar * path, time_t regtime)
{
DIR *dir;
struct dirent *dirent;
gboolean is_dir;
gchar *new_path;
time_t pathtime = get_time (path, &is_dir);
if (is_dir) {
dir = opendir (path);
if (dir) {
while ((dirent = readdir (dir))) {
/* don't want to recurse in place or backwards */
if (strcmp (dirent->d_name, ".") && strcmp (dirent->d_name, "..")) {
new_path = g_build_filename (path, dirent->d_name, NULL);
if (!plugin_times_older_than_recurse (new_path, regtime)) {
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING,
"path %s is more recent than registry time of %ld",
new_path, (long) regtime);
g_free (new_path);
closedir (dir);
return FALSE;
}
g_free (new_path);
}
}
closedir (dir);
}
return TRUE;
}
/* it's a file */
if (pathtime <= regtime) {
return TRUE;
}
/* it's a file, and it's more recent */
if (g_str_has_suffix (path, ".so") || g_str_has_suffix (path, ".dll")) {
if (!gst_plugin_check_file (path, NULL))
return TRUE;
/* it's a newer GStreamer plugin */
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING,
"%s looks like a plugin and is more recent than registry time of %ld",
path, (long) regtime);
return FALSE;
}
return TRUE;
}
/* return TRUE iff regtime is more recent than the times of all the .so files
* in the plugin dirs; ie return TRUE if registry is up to date.
*/
static gboolean
plugin_times_older_than (GList * paths, time_t regtime)
{
while (paths) {
GST_CAT_LOG (GST_CAT_PLUGIN_LOADING,
"comparing plugin times from %s with %ld",
(gchar *) paths->data, (long) regtime);
if (!plugin_times_older_than_recurse (paths->data, regtime))
return FALSE;
paths = g_list_next (paths);
}
GST_CAT_LOG (GST_CAT_PLUGIN_LOADING,
"everything's fine, no registry rebuild needed.");
return TRUE;
}
static gboolean
gst_xml_registry_open_func (GstXMLRegistry * registry, GstXMLRegistryMode mode)
{
GstRegistry *gst_registry;
GList *paths;
gst_registry = GST_REGISTRY (registry);
paths = gst_registry->paths;
GST_CAT_DEBUG (GST_CAT_GST_INIT, "opening registry %s", registry->location);
g_return_val_if_fail (registry->open == FALSE, FALSE);
/* if it doesn't exist, first try to build it, and check if it worked
* if it's not readable, return false
* if it's out of date, rebuild it */
if (mode == GST_XML_REGISTRY_READ) {
if (!(gst_registry->flags & GST_REGISTRY_EXISTS)) {
/* if it's not writable, then don't bother */
if (!(gst_registry->flags & GST_REGISTRY_WRITABLE)) {
GST_CAT_INFO (GST_CAT_GST_INIT, "Registry isn't writable");
return FALSE;
}
GST_CAT_INFO (GST_CAT_GST_INIT,
"Registry doesn't exist, trying to build...");
gst_registry_rebuild (gst_registry);
gst_registry_save (gst_registry);
/* FIXME: verify that the flags actually get updated ! */
if (!(gst_registry->flags & GST_REGISTRY_EXISTS)) {
return FALSE;
}
}
/* at this point we know it exists */
g_return_val_if_fail (gst_registry->flags & GST_REGISTRY_READABLE, FALSE);
if (!plugin_times_older_than (paths, get_time (registry->location, NULL))) {
if (gst_registry->flags & GST_REGISTRY_WRITABLE) {
GST_CAT_INFO (GST_CAT_GST_INIT, "Registry out of date, rebuilding...");
gst_registry_rebuild (gst_registry);
gst_registry_save (gst_registry);
if (!plugin_times_older_than (paths, get_time (registry->location,
NULL))) {
GST_CAT_INFO (GST_CAT_GST_INIT,
"Registry still out of date, something is wrong...");
return FALSE;
}
} else {
GST_CAT_INFO (GST_CAT_GST_INIT,
"Can't write to this registry and it's out of date, ignoring it");
return FALSE;
}
}
GST_CAT_DEBUG (GST_CAT_GST_INIT, "opening registry %s for reading",
registry->location);
registry->regfile = fopen (registry->location, "r");
} else if (mode == GST_XML_REGISTRY_WRITE) {
char *tmploc;
int fd;
g_return_val_if_fail (gst_registry->flags & GST_REGISTRY_WRITABLE, FALSE);
tmploc = g_strconcat (registry->location, ".tmp", NULL);
GST_CAT_DEBUG (GST_CAT_GST_INIT, "opening registry %s for writing", tmploc);
if ((fd = open (tmploc, O_WRONLY | O_CREAT, 0644)) < 0) {
g_free (tmploc);
return FALSE;
}
g_free (tmploc);
registry->regfile = fdopen (fd, "w");
}
if (!registry->regfile)
return FALSE;
registry->open = TRUE;
return TRUE;
}
static gboolean
gst_xml_registry_load_func (GstXMLRegistry * registry, gchar * data,
gssize * size)
{
*size = fread (data, 1, *size, registry->regfile);
return TRUE;
}
static gboolean
gst_xml_registry_save_func (GstXMLRegistry * registry, gchar * format, ...)
{
va_list var_args;
va_start (var_args, format);
vfprintf (registry->regfile, format, var_args);
va_end (var_args);
return TRUE;
}
static gboolean
gst_xml_registry_close_func (GstXMLRegistry * registry)
{
char *tmploc;
GST_CAT_DEBUG (GST_CAT_GST_INIT, "closing registry %s", registry->location);
fclose (registry->regfile);
/* If we opened for writing, rename our temporary file. */
tmploc = g_strconcat (registry->location, ".tmp", NULL);
if (g_file_test (tmploc, G_FILE_TEST_EXISTS)) {
#ifdef WIN32
remove (registry->location);
#endif
rename (tmploc, registry->location);
}
g_free (tmploc);
registry->open = FALSE;
return TRUE;
}
static gboolean
gst_xml_registry_load (GstRegistry * registry)
{
GstXMLRegistry *xmlregistry;
gchar *text;
gssize size;
GError *error = NULL;
GTimer *timer;
gdouble seconds;
xmlregistry = GST_XML_REGISTRY (registry);
timer = g_timer_new ();
xmlregistry->context =
g_markup_parse_context_new (&gst_xml_registry_parser, 0, registry, NULL);
if (!CLASS (xmlregistry)->open_func (xmlregistry, GST_XML_REGISTRY_READ)) {
g_timer_destroy (timer);
return FALSE;
}
text = g_malloc0 (BLOCK_SIZE + 32);
size = BLOCK_SIZE;
CLASS (xmlregistry)->load_func (xmlregistry, text, &size);
while (size) {
g_markup_parse_context_parse (xmlregistry->context, text, size, &error);
if (error) {
GST_ERROR ("parsing registry: %s\n", error->message);
g_free (text);
CLASS (xmlregistry)->close_func (xmlregistry);
g_timer_destroy (timer);
return FALSE;
}
size = BLOCK_SIZE;
CLASS (xmlregistry)->load_func (xmlregistry, text, &size);
}
g_free (text);
g_timer_stop (timer);
seconds = g_timer_elapsed (timer, NULL);
g_timer_destroy (timer);
GST_INFO ("loaded %s in %f seconds (%s)",
registry->name, seconds, xmlregistry->location);
CLASS (xmlregistry)->close_func (xmlregistry);
g_markup_parse_context_free (xmlregistry->context);
return TRUE;
}
static GstRegistryReturn
gst_xml_registry_load_plugin (GstRegistry * registry, GstPlugin * plugin)
{
GError *error = NULL;
GstPlugin *loaded_plugin;
/* FIXME: add gerror support */
loaded_plugin = gst_plugin_load_file (plugin->filename, &error);
if (!plugin) {
if (error) {
g_warning ("could not load plugin %s: %s", plugin->desc.name,
error->message);
g_error_free (error);
}
return GST_REGISTRY_PLUGIN_LOAD_ERROR;
} else if (loaded_plugin != plugin) {
g_critical ("how to remove plugins?");
}
return GST_REGISTRY_OK;
}
static gboolean
gst_xml_registry_parse_plugin (GMarkupParseContext * context, const gchar * tag,
const gchar * text, gsize text_len, GstXMLRegistry * registry,
GError ** error)
{
GstPlugin *plugin = registry->current_plugin;
if (!strcmp (tag, "name")) {
plugin->desc.name = g_strndup (text, text_len);
} else if (!strcmp (tag, "description")) {
plugin->desc.description = g_strndup (text, text_len);
} else if (!strcmp (tag, "filename")) {
plugin->filename = g_strndup (text, text_len);
} else if (!strcmp (tag, "version")) {
plugin->desc.version = g_strndup (text, text_len);
} else if (!strcmp (tag, "license")) {
plugin->desc.license = g_strndup (text, text_len);
} else if (!strcmp (tag, "package")) {
plugin->desc.package = g_strndup (text, text_len);
} else if (!strcmp (tag, "origin")) {
plugin->desc.origin = g_strndup (text, text_len);
}
return TRUE;
}
static void
add_to_char_array (gchar *** array, gchar * value)
{
gchar **new;
gchar **old = *array;
gint i = 0;
/* expensive, but cycles are cheap... */
if (old)
while (old[i])
i++;
new = g_new0 (gchar *, i + 2);
new[i] = value;
while (i > 0) {
i--;
new[i] = old[i];
}
g_free (old);
*array = new;
}
static gboolean
gst_xml_registry_parse_element_factory (GMarkupParseContext * context,
const gchar * tag, const gchar * text, gsize text_len,
GstXMLRegistry * registry, GError ** error)
{
GstElementFactory *factory = GST_ELEMENT_FACTORY (registry->current_feature);
if (!strcmp (tag, "name")) {
gchar *name = g_strndup (text, text_len);
gst_plugin_feature_set_name (registry->current_feature, name);
g_free (name);
} else if (!strcmp (tag, "longname")) {
g_free (factory->details.longname);
factory->details.longname = g_strndup (text, text_len);
} else if (!strcmp (tag, "class")) {
g_free (factory->details.klass);
factory->details.klass = g_strndup (text, text_len);
} else if (!strcmp (tag, "description")) {
g_free (factory->details.description);
factory->details.description = g_strndup (text, text_len);
} else if (!strcmp (tag, "author")) {
g_free (factory->details.author);
factory->details.author = g_strndup (text, text_len);
} else if (!strcmp (tag, "rank")) {
gint rank;
gchar *ret;
rank = strtol (text, &ret, 0);
if (ret == text + text_len) {
gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE (factory), rank);
}
} else if (!strcmp (tag, "uri_type")) {
if (g_ascii_strncasecmp (text, "sink", 4) == 0) {
factory->uri_type = GST_URI_SINK;
} else if (g_ascii_strncasecmp (text, "source", 5) == 0) {
factory->uri_type = GST_URI_SRC;
}
} else if (!strcmp (tag, "uri_protocol")) {
add_to_char_array (&factory->uri_protocols, g_strndup (text, text_len));
} else if (!strcmp (tag, "interface")) {
gchar *tmp = g_strndup (text, text_len);
__gst_element_factory_add_interface (factory, tmp);
g_free (tmp);
}
return TRUE;
}
static gboolean
gst_xml_registry_parse_type_find_factory (GMarkupParseContext * context,
const gchar * tag, const gchar * text, gsize text_len,
GstXMLRegistry * registry, GError ** error)
{
GstTypeFindFactory *factory =
GST_TYPE_FIND_FACTORY (registry->current_feature);
if (!strcmp (tag, "name")) {
registry->current_feature->name = g_strndup (text, text_len);
} else if (!strcmp (tag, "rank")) {
glong rank;
gchar *ret;
rank = strtol (text, &ret, 0);
if (ret == text + text_len) {
gst_plugin_feature_set_rank (GST_PLUGIN_FEATURE (factory), rank);
}
}
/* FIXME!!
else if (!strcmp (tag, "caps")) {
factory->caps = g_strndup (text, text_len);
} */
else if (!strcmp (tag, "extension")) {
add_to_char_array (&factory->extensions, g_strndup (text, text_len));
}
return TRUE;
}
static gboolean
gst_xml_registry_parse_index_factory (GMarkupParseContext * context,
const gchar * tag, const gchar * text, gsize text_len,
GstXMLRegistry * registry, GError ** error)
{
GstIndexFactory *factory = GST_INDEX_FACTORY (registry->current_feature);
if (!strcmp (tag, "name")) {
registry->current_feature->name = g_strndup (text, text_len);
} else if (!strcmp (tag, "longdesc")) {
factory->longdesc = g_strndup (text, text_len);
}
return TRUE;
}
static gboolean
gst_xml_registry_parse_padtemplate (GMarkupParseContext * context,
const gchar * tag, const gchar * text, gsize text_len,
GstXMLRegistry * registry, GError ** error)
{
if (!strcmp (tag, "nametemplate")) {
registry->name_template = g_strndup (text, text_len);
} else if (!strcmp (tag, "direction")) {
if (!strncmp (text, "sink", text_len)) {
registry->direction = GST_PAD_SINK;
} else if (!strncmp (text, "src", text_len)) {
registry->direction = GST_PAD_SRC;
}
} else if (!strcmp (tag, "presence")) {
if (!strncmp (text, "always", text_len)) {
registry->presence = GST_PAD_ALWAYS;
} else if (!strncmp (text, "sometimes", text_len)) {
registry->presence = GST_PAD_SOMETIMES;
} else if (!strncmp (text, "request", text_len)) {
registry->presence = GST_PAD_REQUEST;
}
} else if (!strncmp (tag, "caps", 4)) {
char *s;
s = g_strndup (text, text_len);
g_assert (registry->caps == NULL);
registry->caps = gst_caps_from_string (s);
if (registry->caps == NULL) {
g_critical ("Could not parse caps: length %d, content: %*s",
(int) text_len, (int) text_len, text);
}
g_free (s);
return TRUE;
}
return TRUE;
}
static void
gst_xml_registry_start_element (GMarkupParseContext * context,
const gchar * element_name,
const gchar ** attribute_names,
const gchar ** attribute_values, gpointer user_data, GError ** error)
{
GstXMLRegistry *xmlregistry = GST_XML_REGISTRY (user_data);
xmlregistry->open_tags = g_list_prepend (xmlregistry->open_tags,
g_strdup (element_name));
switch (xmlregistry->state) {
case GST_XML_REGISTRY_NONE:
if (!strcmp (element_name, "GST-PluginRegistry")) {
xmlregistry->state = GST_XML_REGISTRY_TOP;
}
break;
case GST_XML_REGISTRY_TOP:
if (!strncmp (element_name, "plugin", 6)) {
xmlregistry->state = GST_XML_REGISTRY_PLUGIN;
xmlregistry->parser = gst_xml_registry_parse_plugin;
xmlregistry->current_plugin = (GstPlugin *) g_new0 (GstPlugin, 1);
}
break;
case GST_XML_REGISTRY_PLUGIN:
if (!strncmp (element_name, "feature", 7)) {
gint i = 0;
GstPluginFeature *feature = NULL;
xmlregistry->state = GST_XML_REGISTRY_FEATURE;
while (attribute_names[i]) {
if (!strncmp (attribute_names[i], "typename", 8)) {
feature =
GST_PLUGIN_FEATURE (g_object_new (g_type_from_name
(attribute_values[i]), NULL));
break;
}
i++;
}
if (feature) {
xmlregistry->current_feature = feature;
if (GST_IS_ELEMENT_FACTORY (feature)) {
GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
factory->padtemplates = NULL;
xmlregistry->parser = gst_xml_registry_parse_element_factory;
break;
} else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
xmlregistry->parser = gst_xml_registry_parse_type_find_factory;
} else if (GST_IS_INDEX_FACTORY (feature)) {
xmlregistry->parser = gst_xml_registry_parse_index_factory;
} else {
g_warning ("unknown feature type");
}
}
}
break;
case GST_XML_REGISTRY_FEATURE:
if (!strncmp (element_name, "padtemplate", 11)) {
xmlregistry->state = GST_XML_REGISTRY_PADTEMPLATE;
xmlregistry->parser = gst_xml_registry_parse_padtemplate;
xmlregistry->name_template = NULL;
xmlregistry->direction = 0;
xmlregistry->presence = 0;
xmlregistry->caps = NULL;
}
break;
default:
break;
}
}
static void
gst_xml_registry_end_element (GMarkupParseContext * context,
const gchar * element_name, gpointer user_data, GError ** error)
{
GstXMLRegistry *xmlregistry = GST_XML_REGISTRY (user_data);
gchar *open_tag = (gchar *) xmlregistry->open_tags->data;
xmlregistry->open_tags = g_list_remove (xmlregistry->open_tags, open_tag);
g_free (open_tag);
switch (xmlregistry->state) {
case GST_XML_REGISTRY_TOP:
if (!strcmp (element_name, "GST-PluginRegistry")) {
xmlregistry->state = GST_XML_REGISTRY_NONE;
}
break;
case GST_XML_REGISTRY_PLUGIN:
if (!strcmp (element_name, "plugin")) {
xmlregistry->state = GST_XML_REGISTRY_TOP;
xmlregistry->parser = NULL;
gst_registry_add_plugin (GST_REGISTRY (xmlregistry),
xmlregistry->current_plugin);
}
break;
case GST_XML_REGISTRY_FEATURE:
if (!strcmp (element_name, "feature")) {
xmlregistry->state = GST_XML_REGISTRY_PLUGIN;
xmlregistry->parser = gst_xml_registry_parse_plugin;
gst_plugin_add_feature (xmlregistry->current_plugin,
xmlregistry->current_feature);
xmlregistry->current_feature = NULL;
}
break;
case GST_XML_REGISTRY_PADTEMPLATE:
if (!strcmp (element_name, "padtemplate")) {
GstPadTemplate *template;
template = gst_pad_template_new (xmlregistry->name_template,
xmlregistry->direction, xmlregistry->presence, xmlregistry->caps);
g_free (xmlregistry->name_template);
xmlregistry->name_template = NULL;
xmlregistry->caps = NULL;
__gst_element_factory_add_pad_template (GST_ELEMENT_FACTORY
(xmlregistry->current_feature), template);
xmlregistry->state = GST_XML_REGISTRY_FEATURE;
xmlregistry->parser = gst_xml_registry_parse_element_factory;
}
break;
default:
break;
}
}
static void
gst_xml_registry_text (GMarkupParseContext * context, const gchar * text,
gsize text_len, gpointer user_data, GError ** error)
{
GstXMLRegistry *xmlregistry = GST_XML_REGISTRY (user_data);
gchar *open_tag;
if (xmlregistry->open_tags) {
open_tag = (gchar *) xmlregistry->open_tags->data;
if (!strcmp (open_tag, "plugin-path")) {
//gst_plugin_add_path (g_strndup (text, text_len));
} else if (xmlregistry->parser) {
xmlregistry->parser (context, open_tag, text, text_len, xmlregistry,
error);
}
}
}
static void
gst_xml_registry_passthrough (GMarkupParseContext * context,
const gchar * passthrough_text, gsize text_len, gpointer user_data,
GError ** error)
{
}
static void
gst_xml_registry_error (GMarkupParseContext * context, GError * error,
gpointer user_data)
{
GST_ERROR ("%s\n", error->message);
}
static void
gst_xml_registry_paths_start_element (GMarkupParseContext * context,
const gchar * element_name,
const gchar ** attribute_names,
const gchar ** attribute_values, gpointer user_data, GError ** error)
{
GstXMLRegistry *xmlregistry = GST_XML_REGISTRY (user_data);
switch (xmlregistry->state) {
case GST_XML_REGISTRY_NONE:
if (!strcmp (element_name, "GST-PluginRegistry")) {
xmlregistry->state = GST_XML_REGISTRY_TOP;
}
break;
case GST_XML_REGISTRY_TOP:
if (!strcmp (element_name, "gst-registry-paths")) {
xmlregistry->state = GST_XML_REGISTRY_PATHS;
}
break;
case GST_XML_REGISTRY_PATHS:
if (!strcmp (element_name, "path")) {
xmlregistry->state = GST_XML_REGISTRY_PATH;
}
break;
default:
break;
}
}
static void
gst_xml_registry_paths_end_element (GMarkupParseContext * context,
const gchar * element_name, gpointer user_data, GError ** error)
{
GstXMLRegistry *xmlregistry = GST_XML_REGISTRY (user_data);
switch (xmlregistry->state) {
case GST_XML_REGISTRY_PATH:
if (!strcmp (element_name, "path")) {
xmlregistry->state = GST_XML_REGISTRY_PATHS;
}
break;
case GST_XML_REGISTRY_PATHS:
if (!strcmp (element_name, "gst-plugin-paths")) {
xmlregistry->state = GST_XML_REGISTRY_PATHS_DONE;
}
break;
default:
break;
}
}
static void
gst_xml_registry_paths_text (GMarkupParseContext * context, const gchar * text,
gsize text_len, gpointer user_data, GError ** error)
{
GstXMLRegistry *xmlregistry = GST_XML_REGISTRY (user_data);
if (xmlregistry->state == GST_XML_REGISTRY_PATH)
gst_registry_add_path (GST_REGISTRY (xmlregistry), g_strndup (text,
text_len));
}
/*
* Save
*/
#define PUT_ESCAPED(tag,value) \
G_STMT_START{ \
const gchar *toconv = value; \
if (toconv) { \
gchar *v = g_markup_escape_text (toconv, strlen (toconv)); \
CLASS (xmlregistry)->save_func (xmlregistry, "<%s>%s</%s>\n", tag, v, tag); \
g_free (v); \
} \
}G_STMT_END
#define PUT_ESCAPED_INT(tag,value) \
G_STMT_START{ \
gchar *save = g_strdup_printf ("%ld", (glong) value); \
CLASS (xmlregistry)->save_func (xmlregistry, "<%s>%s</%s>\n", tag, save, tag); \
g_free (save); \
}G_STMT_END
static gboolean
gst_xml_registry_save_caps (GstXMLRegistry * xmlregistry, const GstCaps * caps)
{
char *s = gst_caps_to_string (caps);
PUT_ESCAPED ("caps", s);
g_free (s);
return TRUE;
}
static gboolean
gst_xml_registry_save_pad_template (GstXMLRegistry * xmlregistry,
GstPadTemplate * template)
{
gchar *presence;
PUT_ESCAPED ("nametemplate", template->name_template);
CLASS (xmlregistry)->save_func (xmlregistry, "<direction>%s</direction>\n",
(template->direction == GST_PAD_SINK ? "sink" : "src"));
switch (template->presence) {
case GST_PAD_ALWAYS:
presence = "always";
break;
case GST_PAD_SOMETIMES:
presence = "sometimes";
break;
case GST_PAD_REQUEST:
presence = "request";
break;
default:
presence = "unknown";
break;
}
CLASS (xmlregistry)->save_func (xmlregistry, "<presence>%s</presence>\n",
presence);
if (GST_PAD_TEMPLATE_CAPS (template)) {
gst_xml_registry_save_caps (xmlregistry, GST_PAD_TEMPLATE_CAPS (template));
}
return TRUE;
}
static gboolean
gst_xml_registry_save_feature (GstXMLRegistry * xmlregistry,
GstPluginFeature * feature)
{
PUT_ESCAPED ("name", feature->name);
if (feature->rank > 0) {
gint rank = feature->rank;
CLASS (xmlregistry)->save_func (xmlregistry, "<rank>%d</rank>\n", rank);
}
if (GST_IS_ELEMENT_FACTORY (feature)) {
GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
GList *walk;
PUT_ESCAPED ("longname", factory->details.longname);
PUT_ESCAPED ("class", factory->details.klass);
PUT_ESCAPED ("description", factory->details.description);
PUT_ESCAPED ("author", factory->details.author);
walk = factory->padtemplates;
while (walk) {
GstPadTemplate *template = GST_PAD_TEMPLATE (walk->data);
CLASS (xmlregistry)->save_func (xmlregistry, "<padtemplate>\n");
gst_xml_registry_save_pad_template (xmlregistry, template);
CLASS (xmlregistry)->save_func (xmlregistry, "</padtemplate>\n");
walk = g_list_next (walk);
}
walk = factory->interfaces;
while (walk) {
PUT_ESCAPED ("interface", (gchar *) walk->data);
walk = g_list_next (walk);
}
if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {
gchar **protocol;
PUT_ESCAPED ("uri_type",
factory->uri_type == GST_URI_SINK ? "sink" : "source");
g_assert (factory->uri_protocols);
protocol = factory->uri_protocols;
while (*protocol) {
PUT_ESCAPED ("uri_protocol", *protocol);
protocol++;
}
}
} else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
gint i = 0;
if (factory->caps) {
gst_xml_registry_save_caps (xmlregistry, factory->caps);
}
if (factory->extensions) {
while (factory->extensions[i]) {
PUT_ESCAPED ("extension", factory->extensions[i]);
i++;
}
}
} else if (GST_IS_INDEX_FACTORY (feature)) {
PUT_ESCAPED ("longdesc", GST_INDEX_FACTORY (feature)->longdesc);
}
return TRUE;
}
static gboolean
gst_xml_registry_save_plugin (GstXMLRegistry * xmlregistry, GstPlugin * plugin)
{
GList *walk;
PUT_ESCAPED ("name", plugin->desc.name);
PUT_ESCAPED ("description", plugin->desc.description);
PUT_ESCAPED ("filename", plugin->filename);
PUT_ESCAPED ("version", plugin->desc.version);
PUT_ESCAPED ("license", plugin->desc.license);
PUT_ESCAPED ("package", plugin->desc.package);
PUT_ESCAPED ("origin", plugin->desc.origin);
walk = plugin->features;
while (walk) {
GstPluginFeature *feature = GST_PLUGIN_FEATURE (walk->data);
CLASS (xmlregistry)->save_func (xmlregistry, "<feature typename=\"%s\">\n",
g_type_name (G_OBJECT_TYPE (feature)));
gst_xml_registry_save_feature (xmlregistry, feature);
CLASS (xmlregistry)->save_func (xmlregistry, "</feature>\n");
walk = g_list_next (walk);
}
return TRUE;
}
static gboolean
gst_xml_registry_save (GstRegistry * registry)
{
GList *walk;
GstXMLRegistry *xmlregistry;
g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);
g_return_val_if_fail (registry->flags & GST_REGISTRY_WRITABLE, FALSE);
xmlregistry = GST_XML_REGISTRY (registry);
if (!CLASS (xmlregistry)->open_func (xmlregistry, GST_XML_REGISTRY_WRITE)) {
return FALSE;
}
CLASS (xmlregistry)->save_func (xmlregistry, "<?xml version=\"1.0\"?>\n");
CLASS (xmlregistry)->save_func (xmlregistry, "<GST-PluginRegistry>\n");
walk = gst_registry_get_path_list (GST_REGISTRY (registry));
CLASS (xmlregistry)->save_func (xmlregistry, "<gst-plugin-paths>\n");
while (walk) {
CLASS (xmlregistry)->save_func (xmlregistry, "<path>");
CLASS (xmlregistry)->save_func (xmlregistry, (gchar *) walk->data);
CLASS (xmlregistry)->save_func (xmlregistry, "</path>\n");
walk = g_list_next (walk);
}
CLASS (xmlregistry)->save_func (xmlregistry, "</gst-plugin-paths>\n");
walk = registry->plugins;
while (walk) {
GstPlugin *plugin = GST_PLUGIN (walk->data);
CLASS (xmlregistry)->save_func (xmlregistry, "<plugin>\n");
gst_xml_registry_save_plugin (xmlregistry, plugin);
CLASS (xmlregistry)->save_func (xmlregistry, "</plugin>\n");
walk = g_list_next (walk);
}
CLASS (xmlregistry)->save_func (xmlregistry, "</GST-PluginRegistry>\n");
CLASS (xmlregistry)->close_func (xmlregistry);
return TRUE;
}
static GList *
gst_xml_registry_rebuild_recurse (GstXMLRegistry * registry,
const gchar * directory)
{
GList *ret = NULL;
gint dr_len, sf_len;
if (g_file_test (directory, G_FILE_TEST_IS_DIR)) {
GDir *dir = g_dir_open (directory, 0, NULL);
if (dir) {
const gchar *dirent;
while ((dirent = g_dir_read_name (dir))) {
gchar *dirname;
if (*dirent == '=') {
/* =build, =inst, etc. -- automake distcheck directories */
continue;
}
dirname = g_strjoin ("/", directory, dirent, NULL);
ret =
g_list_concat (ret, gst_xml_registry_rebuild_recurse (registry,
dirname));
g_free (dirname);
}
g_dir_close (dir);
}
} else {
dr_len = strlen (directory);
sf_len = strlen (G_MODULE_SUFFIX);
if (dr_len >= sf_len &&
strcmp (directory + dr_len - sf_len, G_MODULE_SUFFIX) == 0) {
ret = g_list_prepend (ret, g_strdup (directory));
}
}
return ret;
}
static gboolean
gst_xml_registry_rebuild (GstRegistry * registry)
{
GList *walk = NULL, *plugins = NULL, *prune = NULL;
GError *error = NULL;
guint length;
GstPlugin *plugin;
GstXMLRegistry *xmlregistry = GST_XML_REGISTRY (registry);
walk = registry->paths;
while (walk) {
gchar *path = (gchar *) walk->data;
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING,
"Rebuilding registry %p in directory %s...", registry, path);
plugins = g_list_concat (plugins,
gst_xml_registry_rebuild_recurse (xmlregistry, path));
walk = g_list_next (walk);
}
do {
length = g_list_length (plugins);
walk = plugins;
while (walk) {
g_assert (walk->data);
plugin = gst_plugin_load_file ((gchar *) walk->data, NULL);
if (plugin) {
prune = g_list_append (prune, walk->data);
gst_registry_add_plugin (registry, plugin);
}
walk = g_list_next (walk);
}
walk = prune;
while (walk) {
plugins = g_list_remove (plugins, walk->data);
g_free (walk->data);
walk = g_list_next (walk);
}
g_list_free (prune);
prune = NULL;
} while (g_list_length (plugins) != length);
walk = plugins;
while (walk) {
if ((plugin = gst_plugin_load_file ((gchar *) walk->data, &error))) {
g_warning ("Bizarre behavior: plugin %s actually loaded",
(gchar *) walk->data);
gst_registry_add_plugin (registry, plugin);
} else {
GST_CAT_INFO (GST_CAT_PLUGIN_LOADING, "Plugin %s failed to load: %s",
(gchar *) walk->data, error->message);
g_free (walk->data);
g_error_free (error);
error = NULL;
}
walk = g_list_next (walk);
}
return TRUE;
}
Reference in a new issue View git blame Copy permalink