488 lines
14 KiB
C
488 lines
14 KiB
C
/* GStreamer
|
|
* Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
|
|
* 2000 Wim Taymans <wtay@chello.be>
|
|
* 2005 David A. Schleef <ds@schleef.org>
|
|
*
|
|
* gstregistryxml.c: GstRegistry object, support routines
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it ulnder 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.
|
|
*/
|
|
|
|
|
|
#include <gst/gstregistrybinary.h>
|
|
|
|
/*
|
|
** Simple handy function to write a memory location to the registry cache file
|
|
*/
|
|
inline static gboolean
|
|
gst_registry_binary_write(GstRegistry *registry, const void *mem, const ssize_t size)
|
|
{
|
|
if (write(registry->cache_file, mem, size) != size)
|
|
{
|
|
GST_ERROR("Failed to write binary registry element: ptr=%p size=%u error=%s\n",
|
|
mem, size, strerror(errno));
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
** Save features GstBinary style
|
|
*/
|
|
static gboolean
|
|
gst_registry_binary_fill_feature(GList **list, GstPluginFeature *orig, GstBinaryPluginFeature *dest, const char *name)
|
|
{
|
|
GstBinaryChunck *chk;
|
|
|
|
if ((chk = calloc(1, sizeof (GstBinaryChunck))) == NULL)
|
|
return FALSE;
|
|
|
|
chk->data = dest;
|
|
chk->size = sizeof (GstBinaryPluginFeature);
|
|
|
|
*list = g_list_append(*list, chk);
|
|
|
|
dest->rank = orig->rank;
|
|
if (!strncpy(dest->typename, name, GST_BINARY_REGISTRY_TYPENAME_TYPENAME_LEN) ||
|
|
!strncpy(dest->name, orig->name, GST_BINARY_REGISTRY_TYPENAME_NAME_LEN))
|
|
{
|
|
GST_ERROR("Failed to write binary registry feature");
|
|
goto fail;
|
|
}
|
|
|
|
if (GST_IS_ELEMENT_FACTORY(orig))
|
|
{
|
|
GstElementFactory *factory = GST_ELEMENT_FACTORY(orig);
|
|
|
|
if (!strncpy(dest->longname, factory->details.longname, GST_BINARY_REGISTRY_TYPENAME_LONGNAME_LEN) ||
|
|
!strncpy(dest->class, factory->details.klass, GST_BINARY_REGISTRY_TYPENAME_CLASS_LEN) ||
|
|
!strncpy(dest->description, factory->details.description, GST_BINARY_REGISTRY_TYPENAME_DESCRIPTION_LEN) ||
|
|
!strncpy(dest->author, factory->details.author, GST_BINARY_REGISTRY_TYPENAME_AUTHOR_LEN))
|
|
{
|
|
GST_ERROR("Failed to write binary registry feature");
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
dest->npadtemplates = dest->ninterfaces = dest->nuritypes = 0;
|
|
return TRUE;
|
|
|
|
fail:
|
|
free(chk);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*
|
|
** Initialize the GstBinaryRegistryMagic, setting both our magic number and gstreamer major/minor version
|
|
*/
|
|
inline static gboolean
|
|
gst_registry_binary_initialize_magic(GstBinaryRegistryMagic *m)
|
|
{
|
|
if (!strncpy(m->magic, GST_MAGIC_BINARY_REGISTRY_STR, GST_MAGIC_BINARY_REGISTRY_LEN) ||
|
|
!strncpy(m->version, GST_MAJORMINOR, GST_BINARY_REGISTRY_VERSION_LEN))
|
|
{
|
|
GST_ERROR("Failed to write magic to the registry magic structure");
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
** Check GstBinaryRegistryMagic validity.
|
|
** Return a pointer pointing right after the magic structure
|
|
*/
|
|
static gchar *
|
|
gst_registry_binary_check_magic(gchar *in)
|
|
{
|
|
GstBinaryRegistryMagic *m = (GstBinaryRegistryMagic *) in;
|
|
|
|
if (m == NULL || m->magic == NULL || m->version == NULL)
|
|
{
|
|
GST_ERROR("Binary registry magic structure is broken");
|
|
return NULL;
|
|
}
|
|
if (strncmp(m->magic, GST_MAGIC_BINARY_REGISTRY_STR, GST_MAGIC_BINARY_REGISTRY_LEN) != 0)
|
|
{
|
|
GST_ERROR("Binary registry magic is different : %02x%02x%02x%02x != %02x%02x%02x%02x",
|
|
GST_MAGIC_BINARY_REGISTRY_STR[0] & 0xff, GST_MAGIC_BINARY_REGISTRY_STR[1] & 0xff,
|
|
GST_MAGIC_BINARY_REGISTRY_STR[2] & 0xff, GST_MAGIC_BINARY_REGISTRY_STR[3] & 0xff,
|
|
m->magic[0] & 0xff, m->magic[1] & 0xff, m->magic[2] & 0xff, m->magic[3] & 0xff);
|
|
return NULL;
|
|
}
|
|
if (strncmp(m->version, GST_MAJORMINOR, GST_BINARY_REGISTRY_VERSION_LEN))
|
|
{
|
|
GST_ERROR("Binary registry magic version is different : %s != %s",
|
|
GST_MAJORMINOR, m->version);
|
|
return NULL;
|
|
}
|
|
return (in + sizeof (GstBinaryRegistryMagic));
|
|
}
|
|
|
|
/*
|
|
** Adapt a GstPlugin to our GstBinaryPluginElement structure, and write it to the
|
|
** registry file.
|
|
*/
|
|
static gboolean
|
|
gst_registry_binary_save_plugin(GList **list, GstRegistry *registry, GstPlugin *plugin)
|
|
{
|
|
GstBinaryPluginElement *e;
|
|
GstBinaryChunck *chk;
|
|
GList *walk;
|
|
|
|
if ((e = calloc(1, sizeof (GstBinaryPluginElement))) == NULL ||
|
|
(chk = calloc(1, sizeof (GstBinaryChunck))) == NULL)
|
|
return FALSE;
|
|
|
|
chk->data = e;
|
|
chk->size = sizeof (GstBinaryPluginElement);
|
|
*list = g_list_append(*list, chk);
|
|
|
|
if (!strncpy(e->name, plugin->desc.name, GST_BINARY_REGISTRY_NAME_LEN) ||
|
|
!strncpy(e->description, plugin->desc.description, GST_BINARY_REGISTRY_DESCRIPTION_LEN) ||
|
|
!strncpy(e->filename, plugin->filename, _POSIX_PATH_MAX) ||
|
|
!strncpy(e->version, plugin->desc.version, GST_BINARY_REGISTRY_VERSION_LEN) ||
|
|
!strncpy(e->license, plugin->desc.license, GST_BINARY_REGISTRY_LICENSE_LEN) ||
|
|
!strncpy(e->source, plugin->desc.source, GST_BINARY_REGISTRY_SOURCE_LEN) ||
|
|
!strncpy(e->package, plugin->desc.package, GST_BINARY_REGISTRY_PACKAGE_LEN) ||
|
|
!strncpy(e->origin, plugin->desc.origin, GST_BINARY_REGISTRY_ORIGIN_LEN))
|
|
{
|
|
GST_DEBUG("Can't adapt GstPlugin to GstBinaryPluginElement");
|
|
goto fail;
|
|
}
|
|
|
|
e->size = plugin->file_size;
|
|
e->m32p = plugin->file_mtime;
|
|
|
|
GList *ft_list = gst_registry_get_feature_list_by_plugin(registry, plugin->desc.name);
|
|
|
|
for (walk = ft_list; walk; walk = g_list_next(walk), e->nfeatures++)
|
|
{
|
|
GstPluginFeature *curfeat = GST_PLUGIN_FEATURE (walk->data);
|
|
GstBinaryPluginFeature *newfeat;
|
|
const char *feat_name = g_type_name(G_OBJECT_TYPE(curfeat));
|
|
|
|
if ((newfeat = calloc(1, sizeof (GstBinaryPluginFeature))) == NULL)
|
|
goto fail;
|
|
|
|
if (!feat_name || !gst_registry_binary_fill_feature(list, curfeat, newfeat, feat_name))
|
|
{
|
|
GST_ERROR("Can't fill plugin feature, aborting.");
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
GST_DEBUG("Found %d features in plugin \"%s\"\n", e->nfeatures, e->name);
|
|
return TRUE;
|
|
|
|
fail:
|
|
free(chk);
|
|
free(e);
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
** Write the cache to file. Part of the code was taken from gstregistryxml.c
|
|
*/
|
|
gboolean
|
|
gst_registry_binary_write_cache(GstRegistry *registry, const char *location)
|
|
{
|
|
GList *walk;
|
|
char *tmp_location;
|
|
GstBinaryRegistryMagic *magic;
|
|
GstBinaryChunck *magic_chunck;
|
|
GList *to_write = NULL;
|
|
|
|
GST_INFO("Writing binary registry cache");
|
|
|
|
g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);
|
|
tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
|
|
registry->cache_file = g_mkstemp (tmp_location);
|
|
if (registry->cache_file == -1)
|
|
{
|
|
char *dir;
|
|
|
|
/* oops, I bet the directory doesn't exist */
|
|
dir = g_path_get_dirname (location);
|
|
g_mkdir_with_parents (dir, 0777);
|
|
g_free (dir);
|
|
|
|
registry->cache_file = g_mkstemp (tmp_location);
|
|
}
|
|
|
|
if (registry->cache_file == -1)
|
|
goto fail;
|
|
|
|
if ((magic = calloc(1, sizeof (GstBinaryRegistryMagic))) == NULL ||
|
|
!gst_registry_binary_initialize_magic(magic))
|
|
goto fail;
|
|
|
|
if ((magic_chunck = calloc(1, sizeof (GstBinaryChunck))) == NULL)
|
|
goto fail;
|
|
|
|
magic_chunck->data = magic;
|
|
magic_chunck->size = sizeof (GstBinaryRegistryMagic);
|
|
to_write = g_list_append(to_write, magic_chunck);
|
|
|
|
/* Iterate trough the list of plugins in the GstRegistry and adapt them to our structures */
|
|
for (walk = g_list_last(registry->plugins); walk; walk = g_list_previous(walk))
|
|
{
|
|
GstPlugin *plugin = GST_PLUGIN(walk->data);
|
|
|
|
if (!plugin->filename)
|
|
continue;
|
|
|
|
if (plugin->flags & GST_PLUGIN_FLAG_CACHED)
|
|
{
|
|
int ret;
|
|
struct stat statbuf;
|
|
|
|
ret = g_stat (plugin->filename, &statbuf);
|
|
if ((ret = g_stat (plugin->filename, &statbuf)) < 0 ||
|
|
plugin->file_mtime != statbuf.st_mtime ||
|
|
plugin->file_size != statbuf.st_size)
|
|
continue;
|
|
}
|
|
|
|
if (!gst_registry_binary_save_plugin(&to_write, registry, plugin))
|
|
{
|
|
GST_ERROR("Can't write binary plugin information for \"%s\"", plugin->filename);
|
|
continue; /* Try anyway */
|
|
}
|
|
}
|
|
|
|
for (walk = g_list_first(to_write); walk; walk = g_list_next(walk))
|
|
{
|
|
GstBinaryChunck *cur = walk->data;
|
|
|
|
if (!gst_registry_binary_write(registry, cur->data, cur->size))
|
|
{
|
|
free(cur->data);
|
|
free(cur);
|
|
g_list_free(to_write);
|
|
goto fail;
|
|
}
|
|
free(cur->data);
|
|
free(cur);
|
|
}
|
|
g_list_free(to_write);
|
|
|
|
if (close(registry->cache_file) < 0)
|
|
{
|
|
GST_DEBUG("Can't close registry file : %s", strerror(errno));
|
|
goto fail;
|
|
}
|
|
|
|
if (g_file_test (tmp_location, G_FILE_TEST_EXISTS)) {
|
|
#ifdef WIN32
|
|
remove (location);
|
|
#endif
|
|
rename (tmp_location, location);
|
|
}
|
|
|
|
g_free (tmp_location);
|
|
return TRUE;
|
|
|
|
fail:
|
|
g_free(tmp_location);
|
|
return FALSE;
|
|
}
|
|
|
|
static GstPluginFeature*
|
|
gst_registry_binary_load_feature(GstBinaryPluginFeature *in)
|
|
{
|
|
GstPluginFeature *feature;
|
|
GType type;
|
|
|
|
if (!in->typename || !*(in->typename))
|
|
return NULL;
|
|
|
|
/* GST_INFO("Plugin feature typename : %s", in->typename);*/
|
|
|
|
if (!(type = g_type_from_name(in->typename)))
|
|
{
|
|
GST_ERROR("Unknown type from typename");
|
|
return NULL;
|
|
}
|
|
feature = g_object_new (type, NULL);
|
|
|
|
if (!feature) {
|
|
GST_ERROR("Can't create feature from type");
|
|
return NULL;
|
|
}
|
|
|
|
if (!GST_IS_PLUGIN_FEATURE (feature)) {
|
|
/* don't really know what it is */
|
|
if (GST_IS_OBJECT (feature))
|
|
gst_object_unref (feature);
|
|
else
|
|
g_object_unref (feature);
|
|
return NULL;
|
|
}
|
|
|
|
feature->name = g_strdup(in->name);
|
|
feature->rank = in->rank;
|
|
|
|
if (GST_IS_ELEMENT_FACTORY(feature))
|
|
{
|
|
GstElementFactory *factory = GST_ELEMENT_FACTORY(feature);
|
|
|
|
factory->details.longname = g_strdup(in->longname);
|
|
factory->details.klass = g_strdup(in->class);
|
|
factory->details.description = g_strdup(in->description);
|
|
factory->details.author = g_strdup(in->author);
|
|
|
|
/* GST_INFO("Element factory : %s", factory->details.longname); */
|
|
}
|
|
|
|
GST_DEBUG("Added feature %p with name %s", feature, feature->name);
|
|
return feature;
|
|
}
|
|
|
|
/*
|
|
** Make a new plugin from current GstBinaryPluginElement structure
|
|
** and save it to the GstRegistry. Return an offset to the next
|
|
** GstBinaryPluginElement structure.
|
|
*/
|
|
static unsigned long
|
|
gst_registry_binary_get_binary_plugin(GstRegistry *registry, gchar *in)
|
|
{
|
|
GstBinaryPluginElement *p = (GstBinaryPluginElement *) in;
|
|
GstPlugin *plugin = NULL;
|
|
GList *plugin_features = NULL;
|
|
GstBinaryPluginFeature *feat;
|
|
unsigned int i;
|
|
unsigned long offset;
|
|
|
|
plugin = g_object_new (GST_TYPE_PLUGIN, NULL);
|
|
|
|
plugin->flags |= GST_PLUGIN_FLAG_CACHED;
|
|
|
|
plugin->desc.name = g_strdup(p->name);
|
|
plugin->desc.description= g_strdup(p->description);
|
|
plugin->filename = g_strdup(p->filename);
|
|
plugin->desc.version = g_strdup(p->version);
|
|
plugin->desc.license = g_strdup(p->license);
|
|
plugin->desc.source = g_strdup(p->source);
|
|
plugin->desc.package = g_strdup(p->package);
|
|
plugin->desc.origin = g_strdup(p->origin);
|
|
plugin->file_mtime = p->m32p;
|
|
plugin->file_size = p->size;
|
|
plugin->basename = g_path_get_basename (plugin->filename);
|
|
|
|
if (plugin->file_mtime < 0 || plugin->file_size < 0)
|
|
{
|
|
GST_ERROR("Plugin time or file size is not valid !");
|
|
g_free(plugin);
|
|
return -1;
|
|
}
|
|
|
|
if (p->nfeatures < 0)
|
|
{
|
|
GST_ERROR("The number of feature structure is not valid !");
|
|
gst_object_unref(plugin);
|
|
return -1;
|
|
}
|
|
|
|
for (feat = (GstBinaryPluginFeature *) (in + sizeof (GstBinaryPluginElement)), i = 0;
|
|
i < p->nfeatures; i++, feat++)
|
|
{
|
|
GstPluginFeature *gstfeat;
|
|
|
|
if ((gstfeat = gst_registry_binary_load_feature(feat)) == NULL)
|
|
{
|
|
g_list_free(plugin_features);
|
|
g_free(plugin);
|
|
GST_ERROR("Error while loading binary feature");
|
|
return -1;
|
|
}
|
|
gstfeat->plugin_name = g_strdup(plugin->desc.name);
|
|
plugin_features = g_list_prepend(plugin_features, gstfeat);
|
|
}
|
|
|
|
GST_DEBUG("Added plugin \"%s\" to global registry from binary registry", plugin->desc.name);
|
|
GList *g;
|
|
|
|
gst_registry_add_plugin (registry, plugin);
|
|
for (g = plugin_features; g; g = g_list_next (g))
|
|
gst_registry_add_feature (registry, GST_PLUGIN_FEATURE (g->data));
|
|
/* g_list_free(plugin_features); */
|
|
|
|
offset = sizeof (GstBinaryPluginElement) + p->nfeatures * sizeof (GstBinaryPluginFeature);
|
|
return offset;
|
|
}
|
|
|
|
|
|
/*
|
|
** Read the cache and adapt it to fill GstRegistry
|
|
*/
|
|
gboolean
|
|
gst_registry_binary_read_cache(GstRegistry *registry, const char *location)
|
|
{
|
|
GMappedFile *mapped = NULL;
|
|
GTimer *timer = NULL;
|
|
gchar *contents = NULL;
|
|
gdouble seconds;
|
|
unsigned long offset, inc;
|
|
gsize size;
|
|
|
|
/* make sure these types exist */
|
|
GST_TYPE_ELEMENT_FACTORY;
|
|
GST_TYPE_TYPE_FIND_FACTORY;
|
|
GST_TYPE_INDEX_FACTORY;
|
|
|
|
timer = g_timer_new ();
|
|
|
|
if ((mapped = g_mapped_file_new(location, FALSE, NULL)) == NULL ||
|
|
(contents = g_mapped_file_get_contents(mapped)) == NULL)
|
|
{
|
|
GST_ERROR("Can't load file : %s", strerror(errno));
|
|
return FALSE;
|
|
}
|
|
if ((contents = gst_registry_binary_check_magic(contents)) == NULL)
|
|
{
|
|
GST_ERROR("Binary registry type not recognized (invalid magic)");
|
|
g_mapped_file_free(mapped);
|
|
return FALSE;
|
|
}
|
|
|
|
if ((size = g_mapped_file_get_length(mapped)) < sizeof (GstBinaryPluginElement))
|
|
{
|
|
GST_INFO("No binary plugins structure to read");
|
|
return TRUE; /* This is not really an error */
|
|
}
|
|
|
|
for (offset = inc = 0; (offset + sizeof (GstBinaryPluginElement)) < size &&
|
|
(inc = gst_registry_binary_get_binary_plugin(registry, contents + offset)) > 0;
|
|
offset += inc)
|
|
; /* May want in the future to do something here */
|
|
if (inc < 0)
|
|
{
|
|
GST_DEBUG("Problem while reading binary registry");
|
|
return FALSE;
|
|
}
|
|
|
|
g_timer_stop (timer);
|
|
seconds = g_timer_elapsed (timer, NULL);
|
|
g_timer_destroy (timer);
|
|
|
|
GST_INFO ("loaded %s in %f seconds", location, seconds);
|
|
|
|
if (mapped)
|
|
g_mapped_file_free (mapped);
|
|
return TRUE;
|
|
}
|