libs/gst/check/libcheck/check.h
libs/gst/controller/Makefile
libs/gst/dataprotocol/Makefile
+libs/gst/helpers/Makefile
libs/gst/net/Makefile
plugins/Makefile
plugins/indexers/Makefile
<SUBSECTION Private>
GST_QUARK
GstQuarkId
+GstPluginLoader
+GstPluginLoaderFuncs
</SECTION>
<SECTION>
gstpipeline.c \
gstplugin.c \
gstpluginfeature.c \
+ gstpluginloader.c \
gstpoll.c \
gstpreset.c \
gstquark.c \
gstquery.c \
gstregistry.c \
+ gstregistrychunks.c \
gstsegment.c \
gststructure.c \
gstsystemclock.c \
glib-compat-private.h \
gst-i18n-lib.h \
gst-i18n-app.h \
+ gstpluginloader.h \
gstquark.h \
gstregistrybinary.h \
+ gstregistrychunks.h \
gst_private.h
gstmarshal.h: gstmarshal.list
/* Private registry functions */
gboolean _priv_gst_registry_remove_cache_plugins (GstRegistry *registry);
void _priv_gst_registry_cleanup (void);
+gboolean _gst_plugin_loader_client_run (void);
/* used in both gststructure.c and gstcaps.c; numbers are completely made up */
#define STRUCTURE_ESTIMATED_STRING_LEN(s) (16 + (s)->fields->len * 22)
gboolean priv_gst_structure_append_to_gstring (const GstStructure * structure,
GString * s);
-
/* registry cache backends */
/* FIXME 0.11: use priv_ prefix */
gboolean gst_registry_binary_read_cache (GstRegistry * registry, const char *location);
((c) == '-') || ((c) == '+') || ((c) == '/') || ((c) == ':') || \
((c) == '.'))
+#ifndef GST_DISABLE_REGISTRY
+/* Secret variable to initialise gst without registry cache */
+extern gboolean _gst_disable_registry_cache;
+#endif
+
/*** debugging categories *****************************************************/
#ifndef GST_REMOVE_GST_DEBUG
--- /dev/null
+/* GStreamer
+ * Copyright (C) 2008 Jan Schmidt <jan.schmidt@sun.com>
+ *
+ * gstpluginloader.c: GstPluginLoader helper for loading plugin files
+ * out of process.
+ *
+ * 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
+
+#ifndef G_OS_WIN32
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+#include <errno.h>
+
+#include <gst/gst_private.h>
+#include <gst/gstconfig.h>
+
+#include <gst/gstpoll.h>
+#include <gst/gstutils.h>
+
+#include <gst/gstpluginloader.h>
+#include <gst/gstregistrychunks.h>
+
+#define GST_CAT_DEFAULT GST_CAT_PLUGIN_LOADING
+
+static GstPluginLoader *plugin_loader_new (GstRegistry * registry);
+static gboolean plugin_loader_free (GstPluginLoader * loader);
+static gboolean plugin_loader_load (GstPluginLoader * loader,
+ const gchar * filename);
+
+const GstPluginLoaderFuncs _priv_gst_plugin_loader_funcs = {
+ plugin_loader_new, plugin_loader_free, plugin_loader_load
+};
+
+struct _GstPluginLoader
+{
+ GstRegistry *registry;
+ GstPoll *fdset;
+
+ gboolean child_started;
+ GPid child_pid;
+ GstPollFD fd_w;
+ GstPollFD fd_r;
+
+ gboolean is_child;
+ gboolean got_plugin_details;
+
+ /* Transmit buffer */
+ guint8 *tx_buf;
+ guint tx_buf_size;
+ guint tx_buf_write;
+ guint tx_buf_read;
+
+ guint32 next_tag;
+
+ guint8 *rx_buf;
+ guint rx_buf_size;
+ gboolean rx_done;
+};
+
+#define PACKET_EXIT 1
+#define PACKET_LOAD_PLUGIN 2
+#define PACKET_STARTING_LOAD 3
+#define PACKET_PLUGIN_DETAILS 4
+
+#define BUF_INIT_SIZE 512
+#define BUF_GROW_EXTRA 512
+#define HEADER_SIZE 8
+#define ALIGNMENT (sizeof (void *))
+
+
+static gboolean gst_plugin_loader_spawn (GstPluginLoader * loader);
+static void put_packet (GstPluginLoader * loader, guint type, guint32 tag,
+ const guint8 * payload, guint32 payload_len);
+static gboolean exchange_packets (GstPluginLoader * l);
+
+static GstPluginLoader *
+plugin_loader_new (GstRegistry * registry)
+{
+ GstPluginLoader *l = g_new0 (GstPluginLoader, 1);
+
+ if (registry)
+ l->registry = gst_object_ref (registry);
+ l->fdset = gst_poll_new (FALSE);
+ gst_poll_fd_init (&l->fd_w);
+ gst_poll_fd_init (&l->fd_r);
+
+ l->tx_buf_size = BUF_INIT_SIZE;
+ l->tx_buf = g_malloc (BUF_INIT_SIZE);
+
+ l->next_tag = 0;
+
+ l->rx_buf_size = BUF_INIT_SIZE;
+ l->rx_buf = g_malloc (BUF_INIT_SIZE);
+
+ return l;
+}
+
+static gboolean
+plugin_loader_free (GstPluginLoader * loader)
+{
+ gboolean got_plugin_details;
+
+ fsync (loader->fd_w.fd);
+
+ if (loader->child_started) {
+ put_packet (loader, PACKET_EXIT, 0, NULL, 0);
+
+ /* Swap packets with the child until it exits */
+ while (!loader->rx_done && exchange_packets (loader)) {
+ };
+
+ close (loader->fd_w.fd);
+ close (loader->fd_r.fd);
+
+#ifndef G_OS_WIN32
+ GST_LOG ("waiting for child process to exit");
+ waitpid (loader->child_pid, NULL, 0);
+#else
+ g_warning ("FIXME: Implement child process shutdown for Win32");
+#endif
+ g_spawn_close_pid (loader->child_pid);
+ } else {
+ close (loader->fd_w.fd);
+ close (loader->fd_r.fd);
+ }
+
+ gst_poll_free (loader->fdset);
+
+ g_free (loader->rx_buf);
+ g_free (loader->tx_buf);
+
+ if (loader->registry)
+ gst_object_unref (loader->registry);
+
+ got_plugin_details = loader->got_plugin_details;
+
+ g_free (loader);
+
+ return got_plugin_details;
+}
+
+static gboolean
+plugin_loader_load (GstPluginLoader * loader, const gchar * filename)
+{
+ if (!loader->child_started) {
+ if (!gst_plugin_loader_spawn (loader))
+ return FALSE;
+ }
+
+ /* Send a packet to the child requesting that it load the given file */
+ GST_LOG_OBJECT (loader->registry,
+ "Sending file %s to child. tag %u", filename, loader->next_tag);
+
+ put_packet (loader, PACKET_LOAD_PLUGIN, loader->next_tag,
+ (guint8 *) filename, strlen (filename) + 1);
+
+ loader->next_tag++;
+
+ if (!exchange_packets (loader))
+ return FALSE;
+
+ return TRUE;
+}
+
+static gboolean
+gst_plugin_loader_spawn (GstPluginLoader * loader)
+{
+ char *helper_bin =
+ "/home/jan/devel/gstreamer/head/gstreamer/libs/gst/helpers/plugin-scanner";
+ char *argv[] = { helper_bin, "-l", NULL };
+
+ if (!g_spawn_async_with_pipes (NULL, argv, NULL,
+ G_SPAWN_DO_NOT_REAP_CHILD /* | G_SPAWN_STDERR_TO_DEV_NULL */ ,
+ NULL, NULL, &loader->child_pid, &loader->fd_w.fd, &loader->fd_r.fd,
+ NULL, NULL))
+ return FALSE;
+
+ gst_poll_add_fd (loader->fdset, &loader->fd_w);
+
+ gst_poll_add_fd (loader->fdset, &loader->fd_r);
+ gst_poll_fd_ctl_read (loader->fdset, &loader->fd_r, TRUE);
+
+ loader->child_started = TRUE;
+
+ return TRUE;
+}
+
+gboolean
+_gst_plugin_loader_client_run ()
+{
+ GstPluginLoader *l;
+
+ l = plugin_loader_new (NULL);
+ if (l == NULL)
+ return FALSE;
+
+ l->fd_w.fd = 1; /* STDOUT */
+ gst_poll_add_fd (l->fdset, &l->fd_w);
+
+ l->fd_r.fd = 0; /* STDIN */
+ gst_poll_add_fd (l->fdset, &l->fd_r);
+ gst_poll_fd_ctl_read (l->fdset, &l->fd_r, TRUE);
+
+ l->is_child = TRUE;
+
+ GST_DEBUG ("Plugin scanner child running. Waiting for instructions");
+
+ /* Loop, listening for incoming packets on the fd and writing responses */
+ while (!l->rx_done && exchange_packets (l));
+
+ plugin_loader_free (l);
+
+ return TRUE;
+}
+
+static void
+put_packet (GstPluginLoader * l, guint type, guint32 tag,
+ const guint8 * payload, guint32 payload_len)
+{
+ guint8 *out;
+ guint len = payload_len + HEADER_SIZE;
+
+ if (l->tx_buf_write + len >= l->tx_buf_size) {
+ l->tx_buf_size = l->tx_buf_write + len + BUF_GROW_EXTRA;
+ l->tx_buf = g_realloc (l->tx_buf, l->tx_buf_size);
+ }
+
+ out = l->tx_buf + l->tx_buf_write;
+
+ out[0] = type;
+ GST_WRITE_UINT24_BE (out + 1, tag);
+ GST_WRITE_UINT32_BE (out + 4, payload_len);
+ memcpy (out + HEADER_SIZE, payload, payload_len);
+
+ l->tx_buf_write += len;
+ gst_poll_fd_ctl_write (l->fdset, &l->fd_w, TRUE);
+}
+
+static void
+put_chunk (GstPluginLoader * l, GstRegistryChunk * chunk, guint * pos)
+{
+ guint padsize = 0;
+ guint len;
+ guint8 *out;
+
+ /* Might need to align the chunk */
+ if (chunk->align && ((*pos) % ALIGNMENT) != 0)
+ padsize = ALIGNMENT - ((*pos) % ALIGNMENT);
+
+ len = padsize + chunk->size;
+
+ if (l->tx_buf_write + len >= l->tx_buf_size) {
+ l->tx_buf_size = l->tx_buf_write + len + BUF_GROW_EXTRA;
+ l->tx_buf = g_realloc (l->tx_buf, l->tx_buf_size);
+ }
+
+ out = l->tx_buf + l->tx_buf_write;
+ memcpy (out + padsize, chunk->data, chunk->size);
+
+ l->tx_buf_write += len;
+ *pos += len;
+
+ gst_poll_fd_ctl_write (l->fdset, &l->fd_w, TRUE);
+};
+
+static gboolean
+write_one (GstPluginLoader * l)
+{
+ guint8 *out;
+ guint32 to_write;
+ int res;
+
+ if (l->tx_buf_read + HEADER_SIZE > l->tx_buf_write)
+ return FALSE;
+
+ out = l->tx_buf + l->tx_buf_read;
+ to_write = GST_READ_UINT32_BE (out + 4) + HEADER_SIZE;
+ l->tx_buf_read += to_write;
+
+ GST_LOG ("Writing packet of size %d bytes to fd %d", to_write, l->fd_w.fd);
+
+ do {
+ res = write (l->fd_w.fd, out, to_write);
+ if (res > 0) {
+ to_write -= res;
+ out += res;
+ }
+ } while (to_write > 0 && res < 0 && (errno == EAGAIN || errno == EINTR));
+
+ if (l->tx_buf_read == l->tx_buf_write) {
+ gst_poll_fd_ctl_write (l->fdset, &l->fd_w, FALSE);
+ l->tx_buf_read = l->tx_buf_write = 0;
+ }
+ return TRUE;
+}
+
+static gboolean
+do_plugin_load (GstPluginLoader * l, const gchar * filename, guint tag)
+{
+ GstPlugin *newplugin;
+ GList *chunks = NULL;
+
+ GST_DEBUG ("Plugin scanner loading file %s. tag %u\n", filename, tag);
+ put_packet (l, PACKET_STARTING_LOAD, tag, NULL, 0);
+
+ newplugin = gst_plugin_load_file ((gchar *) filename, NULL);
+ if (newplugin) {
+ guint hdr_pos;
+ guint offset;
+
+ /* Now serialise the plugin details and send */
+ if (!_priv_gst_registry_chunks_save_plugin (&chunks,
+ gst_registry_get_default (), newplugin))
+ goto fail;
+
+ /* Store where the header is, write an empty one, then write
+ * all the payload chunks, then fix up the header size */
+ hdr_pos = l->tx_buf_write;
+ offset = HEADER_SIZE;
+ put_packet (l, PACKET_PLUGIN_DETAILS, tag, NULL, 0);
+
+ if (chunks) {
+ GList *walk;
+ for (walk = chunks; walk; walk = g_list_next (walk)) {
+ GstRegistryChunk *cur = walk->data;
+ put_chunk (l, cur, &offset);
+
+ if (!(cur->flags & GST_REGISTRY_CHUNK_FLAG_CONST))
+ g_free (cur->data);
+ g_free (cur);
+ }
+
+ g_list_free (chunks);
+
+ /* Store the size of the written payload */
+ GST_WRITE_UINT32_BE (l->tx_buf + hdr_pos + 4, offset - HEADER_SIZE);
+ }
+
+ gst_object_unref (newplugin);
+ } else {
+ put_packet (l, PACKET_PLUGIN_DETAILS, tag, NULL, 0);
+ }
+
+ return TRUE;
+fail:
+ put_packet (l, PACKET_PLUGIN_DETAILS, tag, NULL, 0);
+ if (chunks) {
+ GList *walk;
+ for (walk = chunks; walk; walk = g_list_next (walk)) {
+ GstRegistryChunk *cur = walk->data;
+
+ if (!(cur->flags & GST_REGISTRY_CHUNK_FLAG_CONST))
+ g_free (cur->data);
+ g_free (cur);
+ }
+
+ g_list_free (chunks);
+ }
+
+ return FALSE;
+}
+
+static gboolean
+handle_rx_packet (GstPluginLoader * l,
+ guint pack_type, guint32 tag, guint8 * payload, guint payload_len)
+{
+ gboolean res = TRUE;
+
+ switch (pack_type) {
+ case PACKET_EXIT:
+ gst_poll_fd_ctl_read (l->fdset, &l->fd_r, FALSE);
+ if (l->is_child) {
+ /* Respond, then we keep looping until the parent closes the fd */
+ put_packet (l, PACKET_EXIT, 0, NULL, 0);
+ } else {
+ l->rx_done = TRUE; /* All done reading from child */
+ }
+ return TRUE;
+ case PACKET_LOAD_PLUGIN:{
+
+ if (!l->is_child)
+ return TRUE;
+
+ /* Payload is the filename to load */
+ res = do_plugin_load (l, (gchar *) payload, tag);
+
+ break;
+ }
+ case PACKET_STARTING_LOAD:
+ GST_LOG_OBJECT (l->registry,
+ "child started loading plugin w/ tag %u", tag);
+ break;
+ case PACKET_PLUGIN_DETAILS:{
+ gchar *tmp = (gchar *) payload;
+
+ GST_DEBUG_OBJECT (l->registry,
+ "child loaded plugin w/ tag %u. %d bytes info", tag, payload_len);
+
+ if (payload_len > 0) {
+ GstPlugin *newplugin;
+ _priv_gst_registry_chunks_load_plugin (l->registry, &tmp,
+ tmp + payload_len, &newplugin);
+ newplugin->flags &= ~GST_PLUGIN_FLAG_CACHED;
+ GST_LOG_OBJECT (l->registry,
+ "marking plugin %p as registered as %s", newplugin,
+ newplugin->filename);
+ newplugin->registered = TRUE;
+
+ /* We got a set of plugin details - remember it for later */
+ l->got_plugin_details = TRUE;
+ }
+
+ break;
+ }
+ default:
+ return FALSE; /* Invalid packet -> something is wrong */
+ }
+
+ return res;
+}
+
+static gboolean
+read_one (GstPluginLoader * l)
+{
+ guint32 to_read, packet_len, tag;
+ guint8 *in;
+ gint res;
+
+ to_read = HEADER_SIZE;
+ in = l->rx_buf;
+ do {
+ res = read (l->fd_r.fd, in, to_read);
+ if (res > 0) {
+ to_read -= res;
+ in += res;
+ }
+ } while (to_read > 0 && res < 0 && (errno == EAGAIN || errno == EINTR));
+
+ if (res < 0) {
+ GST_LOG ("Failed reading packet header");
+ return FALSE;
+ }
+
+ packet_len = GST_READ_UINT32_BE (l->rx_buf + 4);
+
+ if (packet_len + HEADER_SIZE >= l->rx_buf_size) {
+ l->rx_buf_size = packet_len + HEADER_SIZE + BUF_GROW_EXTRA;
+ l->rx_buf = g_realloc (l->rx_buf, l->rx_buf_size);
+ }
+
+ in = l->rx_buf + HEADER_SIZE;
+ to_read = packet_len;
+ do {
+ res = read (l->fd_r.fd, in, to_read);
+ if (res > 0) {
+ to_read -= res;
+ in += res;
+ }
+ } while (to_read > 0 && res < 0 && (errno == EAGAIN || errno == EINTR));
+
+ if (res < 0) {
+ GST_ERROR ("Packet payload read failed");
+ return FALSE;
+ }
+
+ tag = GST_READ_UINT24_BE (l->rx_buf + 1);
+
+ return handle_rx_packet (l, l->rx_buf[0], tag,
+ l->rx_buf + HEADER_SIZE, packet_len);
+}
+
+static gboolean
+exchange_packets (GstPluginLoader * l)
+{
+ gint res;
+
+ /* Wait for activity on our FDs */
+ do {
+ do {
+ res = gst_poll_wait (l->fdset, GST_CLOCK_TIME_NONE);
+ } while (res == -1 && (errno == EINTR || errno == EAGAIN));
+
+ if (res < 0)
+ return FALSE;
+
+ GST_DEBUG ("Poll res = %d. %d bytes pending for write", res,
+ l->tx_buf_write - l->tx_buf_read);
+
+ if (!l->rx_done) {
+ if (gst_poll_fd_has_error (l->fdset, &l->fd_r) ||
+ gst_poll_fd_has_closed (l->fdset, &l->fd_r)) {
+ GST_LOG ("read fd %d closed/errored", l->fd_r.fd);
+ return FALSE;
+ }
+
+ if (gst_poll_fd_can_read (l->fdset, &l->fd_r)) {
+ if (!read_one (l))
+ return FALSE;
+ }
+ }
+
+ if (l->tx_buf_read < l->tx_buf_write) {
+ if (gst_poll_fd_has_error (l->fdset, &l->fd_w) ||
+ gst_poll_fd_has_closed (l->fdset, &l->fd_r)) {
+ GST_ERROR ("write fd %d closed/errored", l->fd_w.fd);
+ return FALSE;
+ }
+ if (gst_poll_fd_can_write (l->fdset, &l->fd_w)) {
+ if (!write_one (l))
+ return FALSE;
+ }
+ }
+ } while (l->tx_buf_read < l->tx_buf_write);
+
+ return TRUE;
+}
--- /dev/null
+/* GStreamer
+ * Copyright (C) 2008 Jan Schmidt <jan.schmidt@sun.com>
+ *
+ * gstpluginloader.h: Helper for out-of-process plugin loading. Private header.
+ *
+ * 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.
+ */
+#ifndef __GST_PLUGINLOADER_H__
+#define __GST_PLUGINLOADER_H__
+
+G_BEGIN_DECLS
+
+typedef struct _GstPluginLoader GstPluginLoader;
+
+typedef struct _GstPluginLoaderFuncs {
+ GstPluginLoader * (*create)(GstRegistry *registry);
+ gboolean (*destroy)(GstPluginLoader *loader);
+ gboolean (*load)(GstPluginLoader *loader, const gchar *filename);
+} GstPluginLoaderFuncs;
+
+extern const GstPluginLoaderFuncs _priv_gst_plugin_loader_funcs;
+
+G_END_DECLS
+
+#endif /* __GST_PLUGINLOADER_H__ */
#include "gstmarshal.h"
#include "gstfilter.h"
+#include "gstpluginloader.h"
+
#include "gst-i18n-lib.h"
#define GST_CAT_DEFAULT GST_CAT_REGISTRY
/*set to TRUE when registry needn't to be updated */
gboolean _priv_gst_disable_registry_update = FALSE;
extern GList *_priv_gst_plugin_paths;
+
+/* Set to TRUE when the registry cache should be disabled */
+gboolean _gst_disable_registry_cache = FALSE;
#endif
/* Element signals and args */
return plugin;
}
+typedef enum
+{
+ REGISTRY_SCAN_HELPER_NOT_STARTED = 0,
+ REGISTRY_SCAN_HELPER_DISABLED,
+ REGISTRY_SCAN_HELPER_RUNNING
+} GstRegistryScanHelperState;
+
+typedef struct
+{
+ GstRegistry *registry;
+ GstRegistryScanHelperState helper_state;
+ GstPluginLoader *helper;
+ gboolean changed;
+} GstRegistryScanContext;
+
+static void
+init_scan_context (GstRegistryScanContext * context, GstRegistry * registry)
+{
+ gboolean do_fork;
+
+ context->registry = registry;
+
+ /* see if forking is enabled and set up the scan helper state accordingly */
+ do_fork = _gst_enable_registry_fork;
+ if (do_fork) {
+ const gchar *fork_env;
+
+ /* forking enabled, see if it is disabled with an env var */
+ if ((fork_env = g_getenv ("GST_REGISTRY_FORK"))) {
+ /* fork enabled for any value different from "no" */
+ do_fork = strcmp (fork_env, "no") != 0;
+ }
+ }
+
+ if (do_fork)
+ context->helper_state = REGISTRY_SCAN_HELPER_NOT_STARTED;
+ else
+ context->helper_state = REGISTRY_SCAN_HELPER_DISABLED;
+
+ context->helper = NULL;
+ context->changed = FALSE;
+}
+
+static void
+clear_scan_context (GstRegistryScanContext * context)
+{
+ if (context->helper) {
+ context->changed |= _priv_gst_plugin_loader_funcs.destroy (context->helper);
+ context->helper = NULL;
+ }
+}
+
+static gboolean
+gst_registry_scan_plugin_file (GstRegistryScanContext * context,
+ const gchar * filename)
+{
+ gboolean changed = FALSE;
+ GstPlugin *newplugin = NULL;
+
+ /* Have a plugin to load - see if the scan-helper needs starting */
+ if (context->helper_state == REGISTRY_SCAN_HELPER_NOT_STARTED) {
+ GST_DEBUG ("Starting plugin scanner for file %s", filename);
+ context->helper = _priv_gst_plugin_loader_funcs.create (context->registry);
+ if (context->helper != NULL)
+ context->helper_state = REGISTRY_SCAN_HELPER_RUNNING;
+ else
+ context->helper_state = REGISTRY_SCAN_HELPER_DISABLED;
+ }
+
+ if (context->helper_state == REGISTRY_SCAN_HELPER_RUNNING) {
+ GST_DEBUG ("Using scan-helper to load plugin %s", filename);
+ if (!_priv_gst_plugin_loader_funcs.load (context->helper, filename)) {
+ g_warning ("External plugin loader failed...");
+ context->helper_state = REGISTRY_SCAN_HELPER_DISABLED;
+ }
+ } else {
+ /* Load plugin the old fashioned way... */
+
+ /* We don't use a GError here because a failure to load some shared
+ * objects as plugins is normal (particularly in the uninstalled case)
+ */
+ newplugin = gst_plugin_load_file (filename, NULL);
+ }
+
+ if (newplugin) {
+ GST_DEBUG_OBJECT (context->registry, "marking new plugin %p as registered",
+ newplugin);
+ newplugin->registered = TRUE;
+ gst_object_unref (newplugin);
+ changed = TRUE;
+ }
+
+ return changed;
+}
+
static gboolean
-gst_registry_scan_path_level (GstRegistry * registry, const gchar * path,
- int level)
+gst_registry_scan_path_level (GstRegistryScanContext * context,
+ const gchar * path, int level)
{
GDir *dir;
const gchar *dirent;
gchar *filename;
GstPlugin *plugin;
- GstPlugin *newplugin;
gboolean changed = FALSE;
dir = g_dir_open (path, 0, NULL);
/* skip the .debug directory, these contain elf files that are not
* useful or worse, can crash dlopen () */
if (g_str_equal (dirent, ".debug") || g_str_equal (dirent, ".git")) {
- GST_LOG_OBJECT (registry, "ignoring .debug or .git directory");
+ GST_LOG_OBJECT (context->registry, "ignoring .debug or .git directory");
g_free (filename);
continue;
}
* is inconsistent with other PATH environment variables
*/
if (level > 0) {
- GST_LOG_OBJECT (registry, "recursing into directory %s", filename);
- changed |= gst_registry_scan_path_level (registry, filename, level - 1);
+ GST_LOG_OBJECT (context->registry, "recursing into directory %s",
+ filename);
+ changed |= gst_registry_scan_path_level (context, filename, level - 1);
} else {
- GST_LOG_OBJECT (registry, "not recursing into directory %s, "
+ GST_LOG_OBJECT (context->registry, "not recursing into directory %s, "
"recursion level too deep", filename);
}
g_free (filename);
continue;
}
if (!(file_status.st_mode & S_IFREG)) {
- GST_LOG_OBJECT (registry, "%s is not a regular file, ignoring", filename);
+ GST_LOG_OBJECT (context->registry, "%s is not a regular file, ignoring",
+ filename);
g_free (filename);
continue;
}
&& !g_str_has_suffix (dirent, GST_EXTRA_MODULE_SUFFIX)
#endif
) {
- GST_LOG_OBJECT (registry, "extension is not recognized as module file, "
- "ignoring file %s", filename);
+ GST_LOG_OBJECT (context->registry,
+ "extension is not recognized as module file, ignoring file %s",
+ filename);
g_free (filename);
continue;
}
- GST_LOG_OBJECT (registry, "file %s looks like a possible module", filename);
+ GST_LOG_OBJECT (context->registry, "file %s looks like a possible module",
+ filename);
/* plug-ins are considered unique by basename; if the given name
* was already seen by the registry, we ignore it */
- plugin = gst_registry_lookup (registry, filename);
+ plugin = gst_registry_lookup (context->registry, filename);
if (plugin) {
gboolean env_vars_changed, deps_changed = FALSE;
if (plugin->registered) {
- GST_DEBUG_OBJECT (registry,
+ GST_DEBUG_OBJECT (context->registry,
"plugin already registered from path \"%s\"",
GST_STR_NULL (plugin->filename));
g_free (filename);
env_vars_changed = _priv_plugin_deps_env_vars_changed (plugin);
+ /* If a file with a certain basename is seen on a different path,
+ * update the plugin to ensure the registry cache will reflect up
+ * to date information */
+
if (plugin->file_mtime == file_status.st_mtime &&
plugin->file_size == file_status.st_size && !env_vars_changed &&
- !(deps_changed = _priv_plugin_deps_files_changed (plugin))) {
- GST_LOG_OBJECT (registry, "file %s cached", filename);
+ !(deps_changed = _priv_plugin_deps_files_changed (plugin)) &&
+ strcmp (plugin->filename, filename) == 0) {
+ GST_LOG_OBJECT (context->registry, "file %s cached", filename);
plugin->flags &= ~GST_PLUGIN_FLAG_CACHED;
- GST_LOG_OBJECT (registry, "marking plugin %p as registered as %s",
- plugin, filename);
+ GST_LOG_OBJECT (context->registry,
+ "marking plugin %p as registered as %s", plugin, filename);
plugin->registered = TRUE;
- /* Update the file path on which we've seen this cached plugin
- * to ensure the registry cache will reflect up to date information */
- if (strcmp (plugin->filename, filename) != 0) {
- g_free (plugin->filename);
- plugin->filename = g_strdup (filename);
- changed = TRUE;
- }
} else {
- GST_INFO_OBJECT (registry, "cached info for %s is stale", filename);
- GST_DEBUG_OBJECT (registry, "mtime %ld != %ld or size %"
+ GST_INFO_OBJECT (context->registry, "cached info for %s is stale",
+ filename);
+ GST_DEBUG_OBJECT (context->registry, "mtime %ld != %ld or size %"
G_GINT64_FORMAT " != %" G_GINT64_FORMAT " or external dependency "
"env_vars changed: %d or external dependencies changed: %d",
plugin->file_mtime, file_status.st_mtime,
(gint64) plugin->file_size, (gint64) file_status.st_size,
env_vars_changed, deps_changed);
- gst_registry_remove_plugin (gst_registry_get_default (), plugin);
- /* We don't use a GError here because a failure to load some shared
- * objects as plugins is normal (particularly in the uninstalled case)
- */
- newplugin = gst_plugin_load_file (filename, NULL);
- if (newplugin) {
- GST_DEBUG_OBJECT (registry, "marking new plugin %p as registered",
- newplugin);
- newplugin->registered = TRUE;
- gst_object_unref (newplugin);
- }
- changed = TRUE;
+ gst_registry_remove_plugin (context->registry, plugin);
+ changed |= gst_registry_scan_plugin_file (context, filename);
}
gst_object_unref (plugin);
} else {
- GST_DEBUG_OBJECT (registry, "file %s not yet in registry", filename);
- newplugin = gst_plugin_load_file (filename, NULL);
- if (newplugin) {
- newplugin->registered = TRUE;
- gst_object_unref (newplugin);
- changed = TRUE;
- }
+ GST_DEBUG_OBJECT (context->registry, "file %s not yet in registry",
+ filename);
+ changed |= gst_registry_scan_plugin_file (context, filename);
}
g_free (filename);
return changed;
}
+static gboolean
+gst_registry_scan_path_internal (GstRegistryScanContext * context,
+ const gchar * path)
+{
+ gboolean changed;
+
+ GST_DEBUG_OBJECT (context->registry, "scanning path %s", path);
+ changed = gst_registry_scan_path_level (context, path, 10);
+
+ GST_DEBUG_OBJECT (context->registry, "registry changed in path %s: %d", path,
+ changed);
+ return changed;
+}
+
/**
* gst_registry_scan_path:
* @registry: the registry to add found plugins to
gboolean
gst_registry_scan_path (GstRegistry * registry, const gchar * path)
{
- gboolean changed;
+ GstRegistryScanContext context;
+ gboolean result;
g_return_val_if_fail (GST_IS_REGISTRY (registry), FALSE);
g_return_val_if_fail (path != NULL, FALSE);
- GST_DEBUG_OBJECT (registry, "scanning path %s", path);
- changed = gst_registry_scan_path_level (registry, path, 10);
+ init_scan_context (&context, registry);
- GST_DEBUG_OBJECT (registry, "registry changed in path %s: %d", path, changed);
+ result = gst_registry_scan_path_internal (&context, path);
- return changed;
+ clear_scan_context (&context);
+ result |= context.changed;
+
+ return result;
}
static gboolean
const gchar *plugin_path;
gboolean changed = FALSE;
GList *l;
+ GstRegistryScanContext context;
+
+ GST_INFO ("Validating plugins from registry cache: %s", registry_file);
+
+ init_scan_context (&context, default_registry);
- GST_INFO ("Validating registry cache: %s", registry_file);
/* It sounds tempting to just compare the mtime of directories with the mtime
* of the registry cache, but it does not work. It would not catch updated
* plugins, which might bring more or less features.
GST_DEBUG ("scanning paths added via --gst-plugin-path");
for (l = _priv_gst_plugin_paths; l != NULL; l = l->next) {
GST_INFO ("Scanning plugin path: \"%s\"", (gchar *) l->data);
- changed |= gst_registry_scan_path (default_registry, (gchar *) l->data);
+ changed |= gst_registry_scan_path_internal (&context, (gchar *) l->data);
}
/* keep plugin_paths around in case a re-scan is forced later on */
GST_DEBUG ("GST_PLUGIN_PATH set to %s", plugin_path);
list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
for (i = 0; list[i]; i++) {
- changed |= gst_registry_scan_path (default_registry, list[i]);
+ changed |= gst_registry_scan_path_internal (&context, list[i]);
}
g_strfreev (list);
} else {
home_plugins = g_build_filename (g_get_home_dir (),
".gstreamer-" GST_MAJORMINOR, "plugins", NULL);
GST_DEBUG ("scanning home plugins %s", home_plugins);
- changed |= gst_registry_scan_path (default_registry, home_plugins);
+ changed |= gst_registry_scan_path_internal (&context, home_plugins);
g_free (home_plugins);
/* add the main (installed) library path */
GST_DEBUG ("scanning main plugins %s", PLUGINDIR);
- changed |= gst_registry_scan_path (default_registry, PLUGINDIR);
+ changed |= gst_registry_scan_path_internal (&context, PLUGINDIR);
#ifdef G_OS_WIN32
{
dir = g_build_filename (base_dir, "lib", "gstreamer-0.10", NULL);
GST_DEBUG ("scanning DLL dir %s", dir);
- changed |= gst_registry_scan_path (default_registry, dir);
+ changed |= gst_registry_scan_path_internal (&context, dir);
g_free (dir);
g_free (base_dir);
GST_DEBUG ("GST_PLUGIN_SYSTEM_PATH set to %s", plugin_path);
list = g_strsplit (plugin_path, G_SEARCHPATH_SEPARATOR_S, 0);
for (i = 0; list[i]; i++) {
- changed |= gst_registry_scan_path (default_registry, list[i]);
+ changed |= gst_registry_scan_path_internal (&context, list[i]);
}
g_strfreev (list);
}
+ clear_scan_context (&context);
+ changed |= context.changed;
+
/* Remove cached plugins so stale info is cleared. */
changed |= gst_registry_remove_cache_plugins (default_registry);
}
static gboolean
-ensure_current_registry_nonforking (GstRegistry * default_registry,
- const gchar * registry_file, GError ** error)
-{
- /* fork() not available */
- GST_DEBUG ("Updating registry cache in-process");
- scan_and_update_registry (default_registry, registry_file, TRUE, error);
- return TRUE;
-}
-
-/* when forking is not available this function always does nothing but return
- * TRUE immediatly */
-static gboolean
-ensure_current_registry_forking (GstRegistry * default_registry,
- const gchar * registry_file, GError ** error)
-{
-#ifdef HAVE_FORK
- pid_t pid;
- int pfd[2];
- int ret;
-
- /* We fork here, and let the child read and possibly rebuild the registry.
- * After that, the parent will re-read the freshly generated registry. */
- GST_DEBUG ("forking to update registry");
-
- if (pipe (pfd) == -1) {
- g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
- _("Error re-scanning registry %s: %s"),
- ", could not create pipes. Error", g_strerror (errno));
- return FALSE;
- }
-
- pid = fork ();
- if (pid == -1) {
- GST_ERROR ("Failed to fork()");
- g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
- _("Error re-scanning registry %s: %s"),
- ", failed to fork. Error", g_strerror (errno));
- return FALSE;
- }
-
- if (pid == 0) {
- gint result_code;
-
- /* this is the child. Close the read pipe */
- (void) close (pfd[0]);
-
- GST_DEBUG ("child reading registry cache");
- result_code =
- scan_and_update_registry (default_registry, registry_file, TRUE, NULL);
-
- /* need to use _exit, so that any exit handlers registered don't
- * bring down the main program */
- GST_DEBUG ("child exiting: %d", result_code);
-
- /* make valgrind happy (yes, you can call it insane) */
- g_free ((char *) registry_file);
-
- /* write a result byte to the pipe */
- do {
- ret = write (pfd[1], &result_code, sizeof (result_code));
- } while (ret == -1 && errno == EINTR);
- /* if ret == -1 now, we could not write to pipe, probably
- * means parent has exited before us */
- (void) close (pfd[1]);
-
- _exit (0);
- } else {
- gint result_code;
-
- /* parent. Close write pipe */
- (void) close (pfd[1]);
-
- /* Wait for result from the pipe */
- GST_DEBUG ("Waiting for data from child");
- do {
- ret = read (pfd[0], &result_code, sizeof (result_code));
- } while (ret == -1 && errno == EINTR);
-
- if (ret == -1) {
- g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
- _("Error re-scanning registry %s: %s"),
- ", read returned error", g_strerror (errno));
- close (pfd[0]);
- return FALSE;
- }
- (void) close (pfd[0]);
-
- /* Wait to ensure the child is reaped, but ignore the result */
- GST_DEBUG ("parent waiting on child");
- waitpid (pid, NULL, 0);
- GST_DEBUG ("parent done waiting on child");
-
- if (ret == 0) {
- GST_ERROR ("child did not exit normally, terminated by signal");
- g_set_error (error, GST_CORE_ERROR, GST_CORE_ERROR_FAILED,
- _("Error re-scanning registry %s"), ", child terminated by signal");
- return FALSE;
- }
-
- if (result_code == REGISTRY_SCAN_AND_UPDATE_SUCCESS_UPDATED) {
- GST_DEBUG ("Child succeeded. Parent reading registry cache");
- gst_registry_remove_cache_plugins (default_registry);
-#ifdef USE_BINARY_REGISTRY
- gst_registry_binary_read_cache (default_registry, registry_file);
-#else
- gst_registry_xml_read_cache (default_registry, registry_file);
-#endif
- } else if (result_code == REGISTRY_SCAN_AND_UPDATE_FAILURE) {
- GST_DEBUG ("Child failed. Parent re-scanning registry, ignoring errors.");
- scan_and_update_registry (default_registry, registry_file, FALSE, NULL);
- }
- }
-#endif /* HAVE_FORK */
- return TRUE;
-}
-
-static gboolean
ensure_current_registry (GError ** error)
{
gchar *registry_file;
GstRegistry *default_registry;
gboolean ret = TRUE;
- gboolean do_update;
- gboolean have_cache;
+ gboolean do_update = TRUE;
+ gboolean have_cache = TRUE;
default_registry = gst_registry_get_default ();
registry_file = g_strdup (g_getenv ("GST_REGISTRY"));
".gstreamer-" GST_MAJORMINOR, "registry." HOST_CPU ".bin", NULL);
}
- GST_INFO ("reading registry cache: %s", registry_file);
- have_cache = gst_registry_binary_read_cache (default_registry, registry_file);
+ if (!_gst_disable_registry_cache) {
+ GST_INFO ("reading registry cache: %s", registry_file);
+ have_cache = gst_registry_binary_read_cache (default_registry,
+ registry_file);
+ }
if (have_cache) {
do_update = !_priv_gst_disable_registry_update;
/* do update for any value different from "no" */
do_update = (strcmp (update_env, "no") != 0);
}
- } else {
- do_update = TRUE;
}
}
#ifndef __GST_REGISTRY_H__
#define __GST_REGISTRY_H__
-#include <stdio.h> /* FIXME: because of cache_file below */
#include <gst/gstconfig.h>
#include <gst/gstplugin.h>
#include <gst/gstpluginfeature.h>
#include <gst/gstenumtypes.h>
#include <gst/gstpadtemplate.h>
+#include <gst/gstregistrychunks.h>
#include <gst/gstregistrybinary.h>
#include <glib/gstdio.h> /* for g_stat(), g_mapped_file(), ... */
#define GST_CAT_DEFAULT GST_CAT_REGISTRY
-/* count string length, but return -1 if we hit the eof */
-static gint
-_strnlen (const gchar * str, gint maxlen)
-{
- gint len = 0;
-
- if (G_UNLIKELY (len == maxlen))
- return -1;
-
- while (*str++ != '\0') {
- len++;
- if (G_UNLIKELY (len == maxlen))
- return -1;
- }
- return len;
-}
-
/* reading macros */
-
#define unpack_element(inptr, outptr, element, endptr, error_label) G_STMT_START{ \
if (inptr + sizeof(element) >= endptr) \
goto error_label; \
inptr += sizeof (element); \
}G_STMT_END
-#define unpack_const_string(inptr, outptr, endptr, error_label) G_STMT_START{\
- gint _len = _strnlen (inptr, (endptr-inptr)); \
- if (_len == -1) \
- goto error_label; \
- outptr = g_intern_string ((const gchar *)inptr); \
- inptr += _len + 1; \
-}G_STMT_END
-
-#define unpack_string(inptr, outptr, endptr, error_label) G_STMT_START{\
- gint _len = _strnlen (inptr, (endptr-inptr)); \
- if (_len == -1) \
- goto error_label; \
- outptr = g_memdup ((gconstpointer)inptr, _len + 1); \
- inptr += _len + 1; \
-}G_STMT_END
-
#define ALIGNMENT (sizeof (void *))
#define alignment(_address) (gsize)_address%ALIGNMENT
#define align(_ptr) _ptr += (( alignment(_ptr) == 0) ? 0 : ALIGNMENT-alignment(_ptr))
}
static int
-gst_registry_binary_cache_write (GstRegistry * registry,
- BinaryRegistryCache * cache, unsigned long offset,
- const void *data, int length)
+gst_registry_binary_cache_write (BinaryRegistryCache * cache,
+ unsigned long offset, const void *data, int length)
{
cache->len = MAX (offset + length, cache->len);
cache->mem = g_realloc (cache->mem, cache->len);
}
static gboolean
-gst_registry_binary_cache_finish (GstRegistry * registry,
- BinaryRegistryCache * cache, gboolean success)
+gst_registry_binary_cache_finish (BinaryRegistryCache * cache, gboolean success)
{
gboolean ret = TRUE;
GError *error = NULL;
if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,
cache->len, &error)) {
- GST_ERROR ("Failed to write to cache file: %s", error->message);
+ /* Probably the directory didn't exist; create it */
+ gchar *dir;
+ dir = g_path_get_dirname (cache->location);
+ g_mkdir_with_parents (dir, 0777);
+ g_free (dir);
+
g_error_free (error);
- ret = FALSE;
+ error = NULL;
+
+ if (!g_file_set_contents (cache->location, (const gchar *) cache->mem,
+ cache->len, &error)) {
+ GST_ERROR ("Failed to write to cache file: %s", error->message);
+ g_error_free (error);
+ ret = FALSE;
+ }
}
}
const char *location;
char *tmp_location;
unsigned long currentoffset;
+ int cache_fd;
} BinaryRegistryCache;
static BinaryRegistryCache *
cache->location = location;
cache->tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
- registry->cache_file = g_mkstemp (cache->tmp_location);
- if (registry->cache_file == -1) {
+ cache->cache_fd = g_mkstemp (cache->tmp_location);
+ if (cache->cache_fd == -1) {
gchar *dir;
/* oops, I bet the directory doesn't exist */
/* the previous g_mkstemp call overwrote the XXXXXX placeholder ... */
g_free (cache->tmp_location);
cache->tmp_location = g_strconcat (location, ".tmpXXXXXX", NULL);
- registry->cache_file = g_mkstemp (cache->tmp_location);
+ cache->cache_fd = g_mkstemp (cache->tmp_location);
- if (registry->cache_file == -1) {
+ if (cache->cache_fd == -1) {
GST_DEBUG ("g_mkstemp() failed: %s", g_strerror (errno));
g_free (cache->tmp_location);
g_free (cache);
}
static int
-gst_registry_binary_cache_write (GstRegistry * registry,
- BinaryRegistryCache * cache, unsigned long offset,
- const void *data, int length)
+gst_registry_binary_cache_write (BinaryRegistryCache * cache,
+ unsigned long offset, const void *data, int length)
{
long written;
if (offset != cache->currentoffset) {
- if (lseek (registry->cache_file, offset, SEEK_SET) != 0) {
+ if (lseek (cache->cache_fd, offset, SEEK_SET) != 0) {
GST_ERROR ("Seeking to new offset failed");
return FALSE;
}
cache->currentoffset = offset;
}
- written = write (registry->cache_file, data, length);
+ written = write (cache->cache_fd, data, length);
if (written != length) {
GST_ERROR ("Failed to write to cache file");
}
}
static gboolean
-gst_registry_binary_cache_finish (GstRegistry * registry,
- BinaryRegistryCache * cache, gboolean success)
+gst_registry_binary_cache_finish (BinaryRegistryCache * cache, gboolean success)
{
/* only fsync if we're actually going to use and rename the file below */
- if (success && fsync (registry->cache_file) < 0)
+ if (success && fsync (cache->cache_fd) < 0)
goto fsync_failed;
- if (close (registry->cache_file) < 0)
+ if (close (cache->cache_fd) < 0)
goto close_failed;
if (success) {
/* Only do the rename if we wrote the entire file successfully */
- if (g_rename (cache->tmp_location, cache->location) < 0)
+ if (g_rename (cache->tmp_location, cache->location) < 0) {
+ GST_ERROR ("g_rename() failed: %s", g_strerror (errno));
goto rename_failed;
+ }
}
g_free (cache->tmp_location);
* Returns: %TRUE for success
*/
inline static gboolean
-gst_registry_binary_write_chunk (GstRegistry * registry,
- BinaryRegistryCache * cache, const void *mem,
- const gssize size, unsigned long *file_position, gboolean align)
+gst_registry_binary_write_chunk (BinaryRegistryCache * cache,
+ GstRegistryChunk * chunk, unsigned long *file_position)
{
gchar padder[ALIGNMENT] = { 0, };
int padsize = 0;
/* Padding to insert the struct that requiere word alignment */
- if ((align) && (alignment (*file_position) != 0)) {
+ if ((chunk->align) && (alignment (*file_position) != 0)) {
padsize = ALIGNMENT - alignment (*file_position);
- if (gst_registry_binary_cache_write (registry, cache, *file_position,
+ if (gst_registry_binary_cache_write (cache, *file_position,
padder, padsize) != padsize) {
GST_ERROR ("Failed to write binary registry padder");
return FALSE;
*file_position += padsize;
}
- if (gst_registry_binary_cache_write (registry, cache, *file_position,
- mem, size) != size) {
+ if (gst_registry_binary_cache_write (cache, *file_position,
+ chunk->data, chunk->size) != chunk->size) {
GST_ERROR ("Failed to write binary registry element");
return FALSE;
}
- *file_position += size;
+ *file_position += chunk->size;
return TRUE;
}
return TRUE;
}
-
-/*
- * gst_registry_binary_save_const_string:
- *
- * Store a const string in a binary chunk.
- *
- * Returns: %TRUE for success
- */
-inline static gboolean
-gst_registry_binary_save_const_string (GList ** list, const gchar * str)
-{
- GstBinaryChunk *chunk;
-
- if (G_UNLIKELY (str == NULL)) {
- GST_ERROR ("unexpected NULL string in plugin or plugin feature data");
- str = "";
- }
-
- chunk = g_malloc (sizeof (GstBinaryChunk));
- chunk->data = (gpointer) str;
- chunk->size = strlen ((gchar *) chunk->data) + 1;
- chunk->flags = GST_BINARY_REGISTRY_FLAG_CONST;
- chunk->align = FALSE;
- *list = g_list_prepend (*list, chunk);
- return TRUE;
-}
-
-/*
- * gst_registry_binary_save_string:
- *
- * Store a string in a binary chunk.
- *
- * Returns: %TRUE for success
- */
-inline static gboolean
-gst_registry_binary_save_string (GList ** list, gchar * str)
-{
- GstBinaryChunk *chunk;
-
- chunk = g_malloc (sizeof (GstBinaryChunk));
- chunk->data = str;
- chunk->size = strlen ((gchar *) chunk->data) + 1;
- chunk->flags = GST_BINARY_REGISTRY_FLAG_NONE;
- chunk->align = FALSE;
- *list = g_list_prepend (*list, chunk);
- return TRUE;
-}
-
-
-/*
- * gst_registry_binary_save_data:
- *
- * Store some data in a binary chunk.
- *
- * Returns: the initialized chunk
- */
-inline static GstBinaryChunk *
-gst_registry_binary_make_data (gpointer data, gulong size)
-{
- GstBinaryChunk *chunk;
-
- chunk = g_malloc (sizeof (GstBinaryChunk));
- chunk->data = data;
- chunk->size = size;
- chunk->flags = GST_BINARY_REGISTRY_FLAG_NONE;
- chunk->align = TRUE;
- return chunk;
-}
-
-
-/*
- * gst_registry_binary_save_pad_template:
- *
- * Store pad_templates in binary chunks.
- *
- * Returns: %TRUE for success
- */
-static gboolean
-gst_registry_binary_save_pad_template (GList ** list,
- GstStaticPadTemplate * template)
-{
- GstBinaryPadTemplate *pt;
- GstBinaryChunk *chk;
-
- pt = g_malloc0 (sizeof (GstBinaryPadTemplate));
- chk = gst_registry_binary_make_data (pt, sizeof (GstBinaryPadTemplate));
-
- pt->presence = template->presence;
- pt->direction = template->direction;
-
- /* pack pad template strings */
- gst_registry_binary_save_const_string (list,
- (gchar *) (template->static_caps.string));
- gst_registry_binary_save_const_string (list, template->name_template);
-
- *list = g_list_prepend (*list, chk);
-
- return TRUE;
-}
-
-
-/*
- * gst_registry_binary_save_feature:
- *
- * Store features in binary chunks.
- *
- * Returns: %TRUE for success
- */
-static gboolean
-gst_registry_binary_save_feature (GList ** list, GstPluginFeature * feature)
-{
- const gchar *type_name = g_type_name (G_OBJECT_TYPE (feature));
- GstBinaryPluginFeature *pf = NULL;
- GstBinaryChunk *chk = NULL;
- GList *walk;
-
- if (!type_name) {
- GST_ERROR ("NULL feature type_name, aborting.");
- return FALSE;
- }
-
- if (GST_IS_ELEMENT_FACTORY (feature)) {
- GstBinaryElementFactory *ef;
- GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
-
- ef = g_malloc0 (sizeof (GstBinaryElementFactory));
- chk = gst_registry_binary_make_data (ef, sizeof (GstBinaryElementFactory));
- ef->npadtemplates = ef->ninterfaces = ef->nuriprotocols = 0;
- pf = (GstBinaryPluginFeature *) ef;
-
- /* save interfaces */
- for (walk = factory->interfaces; walk;
- walk = g_list_next (walk), ef->ninterfaces++) {
- gst_registry_binary_save_const_string (list, (gchar *) walk->data);
- }
- GST_DEBUG ("Saved %d Interfaces", ef->ninterfaces);
- /* save uritypes */
- if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {
- if (factory->uri_protocols && *factory->uri_protocols) {
- GstBinaryChunk *subchk;
- gchar **protocol;
-
- subchk =
- gst_registry_binary_make_data (&factory->uri_type,
- sizeof (factory->uri_type));
- subchk->flags = GST_BINARY_REGISTRY_FLAG_CONST;
-
- protocol = factory->uri_protocols;
- while (*protocol) {
- gst_registry_binary_save_const_string (list, *protocol++);
- ef->nuriprotocols++;
- }
- *list = g_list_prepend (*list, subchk);
- GST_DEBUG ("Saved %d UriTypes", ef->nuriprotocols);
- } else {
- g_warning ("GStreamer feature '%s' is URI handler but does not provide"
- " any protocols it can handle", feature->name);
- }
- }
-
- /* save pad-templates */
- for (walk = factory->staticpadtemplates; walk;
- walk = g_list_next (walk), ef->npadtemplates++) {
- GstStaticPadTemplate *template = walk->data;
-
- if (!gst_registry_binary_save_pad_template (list, template)) {
- GST_ERROR ("Can't fill pad template, aborting.");
- goto fail;
- }
- }
-
- /* pack element factory strings */
- gst_registry_binary_save_const_string (list, factory->details.author);
- gst_registry_binary_save_const_string (list, factory->details.description);
- gst_registry_binary_save_const_string (list, factory->details.klass);
- gst_registry_binary_save_const_string (list, factory->details.longname);
- } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
- GstBinaryTypeFindFactory *tff;
- GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
-
- tff = g_malloc0 (sizeof (GstBinaryTypeFindFactory));
- chk =
- gst_registry_binary_make_data (tff, sizeof (GstBinaryTypeFindFactory));
- tff->nextensions = 0;
- pf = (GstBinaryPluginFeature *) tff;
-
- /* save extensions */
- if (factory->extensions) {
- while (factory->extensions[tff->nextensions]) {
- gst_registry_binary_save_const_string (list,
- factory->extensions[tff->nextensions++]);
- }
- }
- /* save caps */
- if (factory->caps) {
- GstCaps *copy = gst_caps_copy (factory->caps);
- gchar *str;
-
- /* we copy the caps here so we can simplify them
- * before saving. This is a lot faster when loading
- * them later on */
- gst_caps_do_simplify (copy);
- str = gst_caps_to_string (copy);
- gst_caps_unref (copy);
- gst_registry_binary_save_string (list, str);
- } else {
- gst_registry_binary_save_const_string (list, "");
- }
-
- } else if (GST_IS_INDEX_FACTORY (feature)) {
- GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
-
- pf = g_malloc0 (sizeof (GstBinaryPluginFeature));
- chk = gst_registry_binary_make_data (pf, sizeof (GstBinaryPluginFeature));
- pf->rank = feature->rank;
-
- /* pack element factory strings */
- gst_registry_binary_save_const_string (list, factory->longdesc);
- } else {
- GST_WARNING ("unhandled feature type '%s'", type_name);
- }
-
- if (pf) {
- pf->rank = feature->rank;
- *list = g_list_prepend (*list, chk);
-
- /* pack plugin feature strings */
- gst_registry_binary_save_const_string (list, feature->name);
- gst_registry_binary_save_const_string (list, (gchar *) type_name);
-
- return TRUE;
- }
-
- /* Errors */
-fail:
- g_free (chk);
- g_free (pf);
- return FALSE;
-}
-
-static gboolean
-gst_registry_binary_save_plugin_dep (GList ** list, GstPluginDep * dep)
-{
- GstBinaryDep *ed;
- GstBinaryChunk *chk;
- gchar **s;
-
- ed = g_new0 (GstBinaryDep, 1);
- chk = gst_registry_binary_make_data (ed, sizeof (GstBinaryDep));
-
- ed->flags = dep->flags;
- ed->n_env_vars = 0;
- ed->n_paths = 0;
- ed->n_names = 0;
-
- ed->env_hash = dep->env_hash;
- ed->stat_hash = dep->stat_hash;
-
- for (s = dep->env_vars; s != NULL && *s != NULL; ++s, ++ed->n_env_vars)
- gst_registry_binary_save_string (list, g_strdup (*s));
-
- for (s = dep->paths; s != NULL && *s != NULL; ++s, ++ed->n_paths)
- gst_registry_binary_save_string (list, g_strdup (*s));
-
- for (s = dep->names; s != NULL && *s != NULL; ++s, ++ed->n_names)
- gst_registry_binary_save_string (list, g_strdup (*s));
-
- *list = g_list_prepend (*list, chk);
-
- GST_LOG ("Saved external plugin dependency");
- return TRUE;
-}
-
-/*
- * gst_registry_binary_save_plugin:
- *
- * 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 *pe;
- GstBinaryChunk *chk;
- GList *plugin_features = NULL;
- GList *walk;
-
- pe = g_malloc0 (sizeof (GstBinaryPluginElement));
- chk = gst_registry_binary_make_data (pe, sizeof (GstBinaryPluginElement));
-
- pe->file_size = plugin->file_size;
- pe->file_mtime = plugin->file_mtime;
- pe->n_deps = 0;
- pe->nfeatures = 0;
-
- /* pack external deps */
- for (walk = plugin->priv->deps; walk != NULL; walk = walk->next) {
- if (!gst_registry_binary_save_plugin_dep (list, walk->data)) {
- GST_ERROR ("Could not save external plugin dependency, aborting.");
- goto fail;
- }
- ++pe->n_deps;
- }
-
- /* pack plugin features */
- plugin_features =
- gst_registry_get_feature_list_by_plugin (registry, plugin->desc.name);
- for (walk = plugin_features; walk; walk = g_list_next (walk), pe->nfeatures++) {
- GstPluginFeature *feature = GST_PLUGIN_FEATURE (walk->data);
-
- if (!gst_registry_binary_save_feature (list, feature)) {
- GST_ERROR ("Can't fill plugin feature, aborting.");
- goto fail;
- }
- }
- GST_DEBUG ("Save plugin '%s' with %d feature(s)", plugin->desc.name,
- pe->nfeatures);
-
- gst_plugin_feature_list_free (plugin_features);
-
- /* pack cache data */
- if (plugin->priv->cache_data) {
- gchar *cache_str = gst_structure_to_string (plugin->priv->cache_data);
- gst_registry_binary_save_string (list, cache_str);
- } else {
- gst_registry_binary_save_const_string (list, "");
- }
-
- /* pack plugin element strings */
- gst_registry_binary_save_const_string (list, plugin->desc.origin);
- gst_registry_binary_save_const_string (list, plugin->desc.package);
- gst_registry_binary_save_const_string (list, plugin->desc.source);
- gst_registry_binary_save_const_string (list, plugin->desc.license);
- gst_registry_binary_save_const_string (list, plugin->desc.version);
- gst_registry_binary_save_const_string (list, plugin->filename);
- gst_registry_binary_save_const_string (list, plugin->desc.description);
- gst_registry_binary_save_const_string (list, plugin->desc.name);
-
- *list = g_list_prepend (*list, chk);
-
- GST_DEBUG ("Found %d features in plugin \"%s\"", pe->nfeatures,
- plugin->desc.name);
- return TRUE;
-
- /* Errors */
-fail:
- gst_plugin_feature_list_free (plugin_features);
- g_free (chk);
- g_free (pe);
- return FALSE;
-}
-
/**
* gst_registry_binary_write_cache:
* @registry: a #GstRegistry
continue;
}
- if (!gst_registry_binary_save_plugin (&to_write, registry, plugin)) {
+ if (!_priv_gst_registry_chunks_save_plugin (&to_write, registry, plugin)) {
GST_ERROR ("Can't write binary plugin information for \"%s\"",
plugin->filename);
}
goto fail_free_list;
/* write magic */
- if (gst_registry_binary_cache_write (registry, cache, file_position,
+ if (gst_registry_binary_cache_write (cache, file_position,
&magic, sizeof (GstBinaryRegistryMagic)) !=
sizeof (GstBinaryRegistryMagic)) {
GST_ERROR ("Failed to write binary registry magic");
/* write out data chunks */
for (walk = to_write; walk; walk = g_list_next (walk)) {
- GstBinaryChunk *cur = walk->data;
+ GstRegistryChunk *cur = walk->data;
+ gboolean res;
- if (!gst_registry_binary_write_chunk (registry, cache, cur->data, cur->size,
- &file_position, cur->align)) {
- goto fail_free_list;
- }
- if (!(cur->flags & GST_BINARY_REGISTRY_FLAG_CONST))
+ res = gst_registry_binary_write_chunk (cache, cur, &file_position);
+ if (!(cur->flags & GST_REGISTRY_CHUNK_FLAG_CONST))
g_free (cur->data);
g_free (cur);
walk->data = NULL;
+ if (!res)
+ goto fail_free_list;
}
g_list_free (to_write);
- if (!gst_registry_binary_cache_finish (registry, cache, TRUE))
+ if (!gst_registry_binary_cache_finish (cache, TRUE))
return FALSE;
return TRUE;
fail_free_list:
{
for (walk = to_write; walk; walk = g_list_next (walk)) {
- GstBinaryChunk *cur = walk->data;
+ GstRegistryChunk *cur = walk->data;
if (cur) {
- if (!(cur->flags & GST_BINARY_REGISTRY_FLAG_CONST))
+ if (!(cur->flags & GST_REGISTRY_CHUNK_FLAG_CONST))
g_free (cur->data);
g_free (cur);
}
g_list_free (to_write);
if (cache)
- (void) gst_registry_binary_cache_finish (registry, cache, FALSE);
+ (void) gst_registry_binary_cache_finish (cache, FALSE);
/* fall through */
}
fail:
return -1;
}
-
-/*
- * gst_registry_binary_load_pad_template:
- *
- * Make a new GstStaticPadTemplate from current GstBinaryPadTemplate structure
- *
- * Returns: new GstStaticPadTemplate
- */
-static gboolean
-gst_registry_binary_load_pad_template (GstElementFactory * factory, gchar ** in,
- gchar * end)
-{
- GstBinaryPadTemplate *pt;
- GstStaticPadTemplate *template = NULL;
-
- align (*in);
- GST_DEBUG ("Reading/casting for GstBinaryPadTemplate at address %p", *in);
- unpack_element (*in, pt, GstBinaryPadTemplate, end, fail);
-
- template = g_new0 (GstStaticPadTemplate, 1);
- template->presence = pt->presence;
- template->direction = pt->direction;
-
- /* unpack pad template strings */
- unpack_const_string (*in, template->name_template, end, fail);
- unpack_string (*in, template->static_caps.string, end, fail);
-
- __gst_element_factory_add_static_pad_template (factory, template);
- GST_DEBUG ("Added pad_template %s", template->name_template);
-
- return TRUE;
-
-fail:
- GST_INFO ("Reading pad template failed");
- g_free (template);
- return FALSE;
-}
-
-
-/*
- * gst_registry_binary_load_feature:
- *
- * Make a new GstPluginFeature from current binary plugin feature structure
- *
- * Returns: new GstPluginFeature
- */
-static gboolean
-gst_registry_binary_load_feature (GstRegistry * registry, gchar ** in,
- gchar * end, const gchar * plugin_name)
-{
- GstBinaryPluginFeature *pf = NULL;
- GstPluginFeature *feature = NULL;
- gchar *type_name = NULL, *str;
- GType type;
- guint i;
-
- /* unpack plugin feature strings */
- unpack_string (*in, type_name, end, fail);
-
- if (G_UNLIKELY (!type_name)) {
- GST_ERROR ("No feature type name");
- return FALSE;
- }
-
- GST_DEBUG ("Plugin '%s' feature typename : '%s'", plugin_name, type_name);
-
- if (G_UNLIKELY (!(type = g_type_from_name (type_name)))) {
- GST_ERROR ("Unknown type from typename '%s' for plugin '%s'", type_name,
- plugin_name);
- g_free (type_name);
- return FALSE;
- }
- if (G_UNLIKELY ((feature = g_object_new (type, NULL)) == NULL)) {
- GST_ERROR ("Can't create feature from type");
- g_free (type_name);
- return FALSE;
- }
-
- if (G_UNLIKELY (!GST_IS_PLUGIN_FEATURE (feature))) {
- GST_ERROR ("typename : '%s' is not a plugin feature", type_name);
- goto fail;
- }
-
- /* unpack more plugin feature strings */
- unpack_string (*in, feature->name, end, fail);
-
- if (GST_IS_ELEMENT_FACTORY (feature)) {
- GstBinaryElementFactory *ef;
- guint n;
- GstElementFactory *factory = GST_ELEMENT_FACTORY_CAST (feature);
-
- align (*in);
- GST_LOG ("Reading/casting for GstBinaryElementFactory at address %p", *in);
- unpack_element (*in, ef, GstBinaryElementFactory, end, fail);
- pf = (GstBinaryPluginFeature *) ef;
-
- /* unpack element factory strings */
- unpack_string (*in, factory->details.longname, end, fail);
- unpack_string (*in, factory->details.klass, end, fail);
- unpack_string (*in, factory->details.description, end, fail);
- unpack_string (*in, factory->details.author, end, fail);
- n = ef->npadtemplates;
- GST_DEBUG ("Element factory : '%s' with npadtemplates=%d",
- factory->details.longname, n);
-
- /* load pad templates */
- for (i = 0; i < n; i++) {
- if (G_UNLIKELY (!gst_registry_binary_load_pad_template (factory, in,
- end))) {
- GST_ERROR ("Error while loading binary pad template");
- goto fail;
- }
- }
-
- /* load uritypes */
- if (G_UNLIKELY ((n = ef->nuriprotocols))) {
- GST_DEBUG ("Reading %d UriTypes at address %p", n, *in);
-
- align (*in);
- factory->uri_type = *((guint *) * in);
- *in += sizeof (factory->uri_type);
- /*unpack_element(*in, &factory->uri_type, factory->uri_type, end, fail); */
-
- factory->uri_protocols = g_new0 (gchar *, n + 1);
- for (i = 0; i < n; i++) {
- unpack_string (*in, str, end, fail);
- factory->uri_protocols[i] = str;
- }
- }
-
- /* load interfaces */
- if (G_UNLIKELY ((n = ef->ninterfaces))) {
- GST_DEBUG ("Reading %d Interfaces at address %p", n, *in);
- for (i = 0; i < n; i++) {
- unpack_string (*in, str, end, fail);
- __gst_element_factory_add_interface (factory, str);
- g_free (str);
- }
- }
- } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
- GstBinaryTypeFindFactory *tff;
- GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
-
- align (*in);
- GST_DEBUG ("Reading/casting for GstBinaryPluginFeature at address %p", *in);
- unpack_element (*in, tff, GstBinaryTypeFindFactory, end, fail);
- pf = (GstBinaryPluginFeature *) tff;
-
- /* load caps */
- unpack_string (*in, str, end, fail);
- factory->caps = (str && *str) ? gst_caps_from_string (str) : NULL;
- g_free (str);
- /* load extensions */
- if (tff->nextensions) {
- GST_DEBUG ("Reading %d Typefind extensions at address %p",
- tff->nextensions, *in);
- factory->extensions = g_new0 (gchar *, tff->nextensions + 1);
- for (i = 0; i < tff->nextensions; i++) {
- unpack_string (*in, str, end, fail);
- factory->extensions[i] = str;
- }
- }
- } else if (GST_IS_INDEX_FACTORY (feature)) {
- GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
-
- align (*in);
- GST_DEBUG ("Reading/casting for GstBinaryPluginFeature at address %p", *in);
- unpack_element (*in, pf, GstBinaryPluginFeature, end, fail);
-
- /* unpack index factory strings */
- unpack_string (*in, factory->longdesc, end, fail);
- } else {
- GST_WARNING ("unhandled factory type : %s", G_OBJECT_TYPE_NAME (feature));
- goto fail;
- }
-
- feature->rank = pf->rank;
-
- /* should already be the interned string, but better make sure */
- feature->plugin_name = g_intern_string (plugin_name);
-
- gst_registry_add_feature (registry, feature);
- GST_DEBUG ("Added feature %s", feature->name);
-
- g_free (type_name);
- return TRUE;
-
- /* Errors */
-fail:
- GST_INFO ("Reading plugin feature failed");
- g_free (type_name);
- if (feature) {
- if (GST_IS_OBJECT (feature))
- gst_object_unref (feature);
- else
- g_object_unref (feature);
- }
- return FALSE;
-}
-
-static gchar **
-gst_registry_binary_load_plugin_dep_strv (gchar ** in, gchar * end, guint n)
-{
- gchar **arr;
-
- if (n == 0)
- return NULL;
-
- arr = g_new0 (gchar *, n + 1);
- while (n > 0) {
- unpack_string (*in, arr[n - 1], end, fail);
- --n;
- }
- return arr;
-fail:
- GST_INFO ("Reading plugin dependency strings failed");
- return NULL;
-}
-
-static gboolean
-gst_registry_binary_load_plugin_dep (GstPlugin * plugin, gchar ** in,
- gchar * end)
-{
- GstPluginDep *dep;
- GstBinaryDep *d;
- gchar **s;
-
- align (*in);
- GST_LOG_OBJECT (plugin, "Unpacking GstBinaryDep from %p", *in);
- unpack_element (*in, d, GstBinaryDep, end, fail);
-
- dep = g_new0 (GstPluginDep, 1);
-
- dep->env_hash = d->env_hash;
- dep->stat_hash = d->stat_hash;
-
- dep->flags = d->flags;
-
- dep->names = gst_registry_binary_load_plugin_dep_strv (in, end, d->n_names);
- dep->paths = gst_registry_binary_load_plugin_dep_strv (in, end, d->n_paths);
- dep->env_vars =
- gst_registry_binary_load_plugin_dep_strv (in, end, d->n_env_vars);
-
- plugin->priv->deps = g_list_append (plugin->priv->deps, dep);
-
- GST_DEBUG_OBJECT (plugin, "Loaded external plugin dependency from registry: "
- "env_hash: %08x, stat_hash: %08x", dep->env_hash, dep->stat_hash);
- for (s = dep->env_vars; s != NULL && *s != NULL; ++s)
- GST_LOG_OBJECT (plugin, " evar: %s", *s);
- for (s = dep->paths; s != NULL && *s != NULL; ++s)
- GST_LOG_OBJECT (plugin, " path: %s", *s);
- for (s = dep->names; s != NULL && *s != NULL; ++s)
- GST_LOG_OBJECT (plugin, " name: %s", *s);
-
- return TRUE;
-fail:
- GST_INFO ("Reading plugin dependency failed");
- return FALSE;
-}
-
-/*
- * gst_registry_binary_load_plugin:
- *
- * Make a new GstPlugin from current GstBinaryPluginElement structure
- * and save it to the GstRegistry. Return an offset to the next
- * GstBinaryPluginElement structure.
- */
-static gboolean
-gst_registry_binary_load_plugin (GstRegistry * registry, gchar ** in,
- gchar * end)
-{
- GstBinaryPluginElement *pe;
- GstPlugin *plugin = NULL;
- gchar *cache_str = NULL;
- guint i, n;
-
- align (*in);
- GST_LOG ("Reading/casting for GstBinaryPluginElement at address %p", *in);
- unpack_element (*in, pe, GstBinaryPluginElement, end, fail);
-
- plugin = g_object_new (GST_TYPE_PLUGIN, NULL);
-
- /* TODO: also set GST_PLUGIN_FLAG_CONST */
- plugin->flags |= GST_PLUGIN_FLAG_CACHED;
- plugin->file_mtime = pe->file_mtime;
- plugin->file_size = pe->file_size;
-
- /* unpack plugin element strings */
- unpack_const_string (*in, plugin->desc.name, end, fail);
- unpack_string (*in, plugin->desc.description, end, fail);
- unpack_string (*in, plugin->filename, end, fail);
- unpack_const_string (*in, plugin->desc.version, end, fail);
- unpack_const_string (*in, plugin->desc.license, end, fail);
- unpack_const_string (*in, plugin->desc.source, end, fail);
- unpack_const_string (*in, plugin->desc.package, end, fail);
- unpack_const_string (*in, plugin->desc.origin, end, fail);
- GST_LOG ("read strings for name='%s'", plugin->desc.name);
- GST_LOG (" desc.description='%s'", plugin->desc.description);
- GST_LOG (" filename='%s'", plugin->filename);
- GST_LOG (" desc.version='%s'", plugin->desc.version);
- GST_LOG (" desc.license='%s'", plugin->desc.license);
- GST_LOG (" desc.source='%s'", plugin->desc.source);
- GST_LOG (" desc.package='%s'", plugin->desc.package);
- GST_LOG (" desc.origin='%s'", plugin->desc.origin);
-
- /* unpack cache data */
- unpack_string (*in, cache_str, end, fail);
- if (*cache_str) {
- plugin->priv->cache_data = gst_structure_from_string (cache_str, NULL);
- }
- g_free (cache_str);
-
- plugin->basename = g_path_get_basename (plugin->filename);
-
- /* Takes ownership of plugin */
- gst_registry_add_plugin (registry, plugin);
- n = pe->nfeatures;
- GST_DEBUG ("Added plugin '%s' plugin with %d features from binary registry",
- plugin->desc.name, n);
-
- /* Load plugin features */
- for (i = 0; i < n; i++) {
- if (G_UNLIKELY (!gst_registry_binary_load_feature (registry, in, end,
- plugin->desc.name))) {
- GST_ERROR ("Error while loading binary feature");
- gst_registry_remove_plugin (registry, plugin);
- goto fail;
- }
- }
-
- /* Load external plugin dependencies */
- for (i = 0; i < pe->n_deps; ++i) {
- if (G_UNLIKELY (!gst_registry_binary_load_plugin_dep (plugin, in, end))) {
- GST_ERROR_OBJECT (plugin, "Could not read external plugin dependency");
- gst_registry_remove_plugin (registry, plugin);
- goto fail;
- }
- }
-
- return TRUE;
-
- /* Errors */
-fail:
- GST_INFO ("Reading plugin failed");
- return FALSE;
-}
-
-
/**
* gst_registry_binary_read_cache:
* @registry: a #GstRegistry
GST_INFO ("Unable to mmap file %s : %s", location, err->message);
g_error_free (err);
err = NULL;
+ }
+
+ if (contents == NULL) {
+ /* Error mmap-ing the cache, try a plain memory read */
+ if (mapped) {
+ g_mapped_file_free (mapped);
+ mapped = NULL;
+ }
g_file_get_contents (location, &contents, &size, &err);
if (err != NULL) {
GST_ERROR ("Can't load file %s : %s", location, g_strerror (errno));
goto Error;
}
- /* check length for header */
- size = g_mapped_file_get_length (mapped);
}
/* in is a cursor pointer, we initialize it with the begin of registry and is updated on each read */
}
/* check if there are plugins in the file */
- if (G_UNLIKELY (!(((gsize) in + sizeof (GstBinaryPluginElement)) <
+ if (G_UNLIKELY (!(((gsize) in + sizeof (GstRegistryChunkPluginElement)) <
(gsize) contents + size))) {
GST_INFO ("No binary plugins structure to read");
/* empty file, this is not an error */
} else {
gchar *end = contents + size;
- /* read as long as we still have space for a GstBinaryPluginElement */
+ /* read as long as we still have space for a GstRegistryChunkPluginElement */
for (;
- ((gsize) in + sizeof (GstBinaryPluginElement)) <
+ ((gsize) in + sizeof (GstRegistryChunkPluginElement)) <
(gsize) contents + size;) {
GST_DEBUG ("reading binary registry %" G_GSIZE_FORMAT "(%x)/%"
G_GSIZE_FORMAT, (gsize) in - (gsize) contents,
(guint) ((gsize) in - (gsize) contents), size);
- if (!gst_registry_binary_load_plugin (registry, &in, end)) {
+ if (!_priv_gst_registry_chunks_load_plugin (registry, &in, end, NULL)) {
GST_ERROR ("Problem while reading binary registry %s", location);
goto Error;
}
/* TODO: once we re-use the pointers to registry contents, return here */
Error:
+ if (err)
+ g_error_free (err);
+
#ifndef GST_DISABLE_GST_DEBUG
g_timer_destroy (timer);
#endif
return res;
}
-
-/* FIXME 0.11: these are here for backwards compatibility */
-
+/* FIXME 0.11: these symbols are here for backwards compatibility and should
+ * be removed or made private */
gboolean
gst_registry_xml_read_cache (GstRegistry * registry, const char *location)
{
#include <gst/gstpad.h>
#include <gst/gstregistry.h>
+G_BEGIN_DECLS
+
/*
* GST_MAGIC_BINARY_REGISTRY_STR:
*
gchar version[GST_MAGIC_BINARY_VERSION_LEN];
} GstBinaryRegistryMagic;
-/*
- * we reference strings directly from the plugins and in this case set CONST to
- * avoid freeing them
- */
-enum {
- GST_BINARY_REGISTRY_FLAG_NONE = 0,
- GST_BINARY_REGISTRY_FLAG_CONST = 1
-};
-
-/*
- * GstBinaryChunk:
- *
- * Header for binary blobs
- */
-typedef struct _GstBinaryChunk
-{
- gpointer data;
- guint size;
- guint flags;
- gboolean align;
-} GstBinaryChunk;
-
-/*
- * GstBinaryPluginElement:
- *
- * @nfeatures: says how many binary plugin feature structures we will have
- * right after the structure itself.
- *
- * A structure containing (staticely) every information needed for a plugin
- */
-
-typedef struct _GstBinaryPluginElement
-{
- gulong file_size;
- gulong file_mtime;
-
- guint n_deps;
-
- guint nfeatures;
-} GstBinaryPluginElement;
-
-/* GstBinaryDep:
- */
-typedef struct _GstBinaryDep
-{
- guint flags;
- guint n_env_vars;
- guint n_paths;
- guint n_names;
-
- guint env_hash;
- guint stat_hash;
-} GstBinaryDep;
-
-/*
- * GstBinaryPluginFeature:
- * @rank: rank of the feature
- *
- * A structure containing the plugin features
- */
-typedef struct _GstBinaryPluginFeature
-{
- gulong rank;
-} GstBinaryPluginFeature;
-
-/*
- * GstBinaryElementFactory:
- * @npadtemplates: stores the number of GstBinaryPadTemplate structures
- * following the structure
- * @ninterfaces: stores the number of interface names following the structure
- * @nuriprotocols: stores the number of protocol strings following the structure
- *
- * A structure containing the element factory fields
- */
-typedef struct _GstBinaryElementFactory
-{
- GstBinaryPluginFeature plugin_feature;
-
- guint npadtemplates;
- guint ninterfaces;
- guint nuriprotocols;
-} GstBinaryElementFactory;
-
-/*
- * GstBinaryTypeFindFactory:
- * @nextensions: stores the number of typefind extensions
- *
- * A structure containing the element factory fields
- */
-typedef struct _GstBinaryTypeFindFactory
-{
- GstBinaryPluginFeature plugin_feature;
-
- guint nextensions;
-} GstBinaryTypeFindFactory;
-
-/*
- * GstBinaryPadTemplate:
- *
- * A structure containing the static pad templates of a plugin feature
- */
-typedef struct _GstBinaryPadTemplate
-{
- guint direction; /* Either 0:"sink" or 1:"src" */
- GstPadPresence presence;
-} GstBinaryPadTemplate;
-
-
/* Function prototypes */
gboolean gst_registry_binary_write_cache(GstRegistry *registry, const char *location);
gboolean gst_registry_binary_read_cache(GstRegistry *registry, const char *location);
+G_END_DECLS
+
#endif /* !__GST_REGISTRYBINARY_H__ */
--- /dev/null
+/* GStreamer
+ * Copyright (C) 2006 Josep Torra <josep@fluendo.com>
+ * 2006 Mathieu Garcia <matthieu@fluendo.com>
+ * 2006,2007 Stefan Kost <ensonic@users.sf.net>
+ * 2008 Sebastian Dröge <slomo@circular-chaos.org>
+ * 2008 Jan Schmidt <jan.schmidt@sun.com>
+ *
+ * gstregistrychunks.c: GstRegistryChunk helper for serialising/deserialising
+ * plugin entries and features.
+ *
+ * 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 <gst/gst_private.h>
+#include <gst/gstconfig.h>
+#include <gst/gstelement.h>
+#include <gst/gsttypefind.h>
+#include <gst/gsttypefindfactory.h>
+#include <gst/gsturi.h>
+#include <gst/gstinfo.h>
+#include <gst/gstenumtypes.h>
+#include <gst/gstpadtemplate.h>
+
+#include <gst/gstregistrychunks.h>
+
+#define GST_CAT_DEFAULT GST_CAT_REGISTRY
+
+/* count string length, but return -1 if we hit the eof */
+static gint
+_strnlen (const gchar * str, gint maxlen)
+{
+ gint len = 0;
+
+ if (G_UNLIKELY (len == maxlen))
+ return -1;
+
+ while (*str++ != '\0') {
+ len++;
+ if (G_UNLIKELY (len == maxlen))
+ return -1;
+ }
+ return len;
+}
+
+/* Macros */
+#define unpack_element(inptr, outptr, element, endptr, error_label) G_STMT_START{ \
+ if (inptr + sizeof(element) >= endptr) \
+ goto error_label; \
+ outptr = (element *) inptr; \
+ inptr += sizeof (element); \
+}G_STMT_END
+
+#define unpack_const_string(inptr, outptr, endptr, error_label) G_STMT_START{\
+ gint _len = _strnlen (inptr, (endptr-inptr)); \
+ if (_len == -1) \
+ goto error_label; \
+ outptr = g_intern_string ((const gchar *)inptr); \
+ inptr += _len + 1; \
+}G_STMT_END
+
+#define unpack_string(inptr, outptr, endptr, error_label) G_STMT_START{\
+ gint _len = _strnlen (inptr, (endptr-inptr)); \
+ if (_len == -1) \
+ goto error_label; \
+ outptr = g_memdup ((gconstpointer)inptr, _len + 1); \
+ inptr += _len + 1; \
+}G_STMT_END
+
+#define ALIGNMENT (sizeof (void *))
+#define alignment(_address) (gsize)_address%ALIGNMENT
+#define align(_ptr) _ptr += (( alignment(_ptr) == 0) ? 0 : ALIGNMENT-alignment(_ptr))
+
+/*
+ * gst_registry_chunks_save_const_string:
+ *
+ * Store a const string in a binary chunk.
+ *
+ * Returns: %TRUE for success
+ */
+inline static gboolean
+gst_registry_chunks_save_const_string (GList ** list, const gchar * str)
+{
+ GstRegistryChunk *chunk;
+
+ if (G_UNLIKELY (str == NULL)) {
+ GST_ERROR ("unexpected NULL string in plugin or plugin feature data");
+ str = "";
+ }
+
+ chunk = g_malloc (sizeof (GstRegistryChunk));
+ chunk->data = (gpointer) str;
+ chunk->size = strlen ((gchar *) chunk->data) + 1;
+ chunk->flags = GST_REGISTRY_CHUNK_FLAG_CONST;
+ chunk->align = FALSE;
+ *list = g_list_prepend (*list, chunk);
+ return TRUE;
+}
+
+/*
+ * gst_registry_chunks_save_string:
+ *
+ * Store a string in a binary chunk.
+ *
+ * Returns: %TRUE for success
+ */
+inline static gboolean
+gst_registry_chunks_save_string (GList ** list, gchar * str)
+{
+ GstRegistryChunk *chunk;
+
+ chunk = g_malloc (sizeof (GstRegistryChunk));
+ chunk->data = str;
+ chunk->size = strlen ((gchar *) chunk->data) + 1;
+ chunk->flags = GST_REGISTRY_CHUNK_FLAG_NONE;
+ chunk->align = FALSE;
+ *list = g_list_prepend (*list, chunk);
+ return TRUE;
+}
+
+/*
+ * gst_registry_chunks_save_data:
+ *
+ * Store some data in a binary chunk.
+ *
+ * Returns: the initialized chunk
+ */
+inline static GstRegistryChunk *
+gst_registry_chunks_make_data (gpointer data, gulong size)
+{
+ GstRegistryChunk *chunk;
+
+ chunk = g_malloc (sizeof (GstRegistryChunk));
+ chunk->data = data;
+ chunk->size = size;
+ chunk->flags = GST_REGISTRY_CHUNK_FLAG_NONE;
+ chunk->align = TRUE;
+ return chunk;
+}
+
+
+/*
+ * gst_registry_chunks_save_pad_template:
+ *
+ * Store pad_templates in binary chunks.
+ *
+ * Returns: %TRUE for success
+ */
+static gboolean
+gst_registry_chunks_save_pad_template (GList ** list,
+ GstStaticPadTemplate * template)
+{
+ GstRegistryChunkPadTemplate *pt;
+ GstRegistryChunk *chk;
+
+ pt = g_malloc0 (sizeof (GstRegistryChunkPadTemplate));
+ chk =
+ gst_registry_chunks_make_data (pt, sizeof (GstRegistryChunkPadTemplate));
+
+ pt->presence = template->presence;
+ pt->direction = template->direction;
+
+ /* pack pad template strings */
+ gst_registry_chunks_save_const_string (list,
+ (gchar *) (template->static_caps.string));
+ gst_registry_chunks_save_const_string (list, template->name_template);
+
+ *list = g_list_prepend (*list, chk);
+
+ return TRUE;
+}
+
+/*
+ * gst_registry_chunks_save_feature:
+ *
+ * Store features in binary chunks.
+ *
+ * Returns: %TRUE for success
+ */
+static gboolean
+gst_registry_chunks_save_feature (GList ** list, GstPluginFeature * feature)
+{
+ const gchar *type_name = g_type_name (G_OBJECT_TYPE (feature));
+ GstRegistryChunkPluginFeature *pf = NULL;
+ GstRegistryChunk *chk = NULL;
+ GList *walk;
+
+ if (!type_name) {
+ GST_ERROR ("NULL feature type_name, aborting.");
+ return FALSE;
+ }
+
+ if (GST_IS_ELEMENT_FACTORY (feature)) {
+ GstRegistryChunkElementFactory *ef;
+ GstElementFactory *factory = GST_ELEMENT_FACTORY (feature);
+
+ ef = g_malloc0 (sizeof (GstRegistryChunkElementFactory));
+ chk =
+ gst_registry_chunks_make_data (ef,
+ sizeof (GstRegistryChunkElementFactory));
+ ef->npadtemplates = ef->ninterfaces = ef->nuriprotocols = 0;
+ pf = (GstRegistryChunkPluginFeature *) ef;
+
+ /* save interfaces */
+ for (walk = factory->interfaces; walk;
+ walk = g_list_next (walk), ef->ninterfaces++) {
+ gst_registry_chunks_save_const_string (list, (gchar *) walk->data);
+ }
+ GST_DEBUG ("Saved %d Interfaces", ef->ninterfaces);
+ /* save uritypes */
+ if (GST_URI_TYPE_IS_VALID (factory->uri_type)) {
+ if (factory->uri_protocols && *factory->uri_protocols) {
+ GstRegistryChunk *subchk;
+ gchar **protocol;
+
+ subchk =
+ gst_registry_chunks_make_data (&factory->uri_type,
+ sizeof (factory->uri_type));
+ subchk->flags = GST_REGISTRY_CHUNK_FLAG_CONST;
+
+ protocol = factory->uri_protocols;
+ while (*protocol) {
+ gst_registry_chunks_save_const_string (list, *protocol++);
+ ef->nuriprotocols++;
+ }
+ *list = g_list_prepend (*list, subchk);
+ GST_DEBUG ("Saved %d UriTypes", ef->nuriprotocols);
+ } else {
+ g_warning ("GStreamer feature '%s' is URI handler but does not provide"
+ " any protocols it can handle", feature->name);
+ }
+ }
+
+ /* save pad-templates */
+ for (walk = factory->staticpadtemplates; walk;
+ walk = g_list_next (walk), ef->npadtemplates++) {
+ GstStaticPadTemplate *template = walk->data;
+
+ if (!gst_registry_chunks_save_pad_template (list, template)) {
+ GST_ERROR ("Can't fill pad template, aborting.");
+ goto fail;
+ }
+ }
+
+ /* pack element factory strings */
+ gst_registry_chunks_save_const_string (list, factory->details.author);
+ gst_registry_chunks_save_const_string (list, factory->details.description);
+ gst_registry_chunks_save_const_string (list, factory->details.klass);
+ gst_registry_chunks_save_const_string (list, factory->details.longname);
+ } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
+ GstRegistryChunkTypeFindFactory *tff;
+ GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
+ gchar *str;
+
+ tff = g_malloc0 (sizeof (GstRegistryChunkTypeFindFactory));
+ chk =
+ gst_registry_chunks_make_data (tff,
+ sizeof (GstRegistryChunkTypeFindFactory));
+ tff->nextensions = 0;
+ pf = (GstRegistryChunkPluginFeature *) tff;
+
+ /* save extensions */
+ if (factory->extensions) {
+ while (factory->extensions[tff->nextensions]) {
+ gst_registry_chunks_save_const_string (list,
+ factory->extensions[tff->nextensions++]);
+ }
+ }
+ /* save caps */
+ if (factory->caps) {
+ /* we copy the caps here so we can simplify them before saving. This
+ * is a lot faster when loading them later on */
+ GstCaps *copy = gst_caps_copy (factory->caps);
+
+ gst_caps_do_simplify (copy);
+ str = gst_caps_to_string (copy);
+ gst_caps_unref (copy);
+ gst_registry_chunks_save_string (list, str);
+ } else {
+ gst_registry_chunks_save_const_string (list, "");
+ }
+ } else if (GST_IS_INDEX_FACTORY (feature)) {
+ GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
+
+ pf = g_malloc0 (sizeof (GstRegistryChunkPluginFeature));
+ chk =
+ gst_registry_chunks_make_data (pf,
+ sizeof (GstRegistryChunkPluginFeature));
+ pf->rank = feature->rank;
+
+ /* pack element factory strings */
+ gst_registry_chunks_save_const_string (list, factory->longdesc);
+ } else {
+ GST_WARNING ("unhandled feature type '%s'", type_name);
+ }
+
+ if (pf) {
+ pf->rank = feature->rank;
+ *list = g_list_prepend (*list, chk);
+
+ /* pack plugin feature strings */
+ gst_registry_chunks_save_const_string (list, feature->name);
+ gst_registry_chunks_save_const_string (list, (gchar *) type_name);
+
+ return TRUE;
+ }
+
+ /* Errors */
+fail:
+ g_free (chk);
+ g_free (pf);
+ return FALSE;
+}
+
+static gboolean
+gst_registry_chunks_save_plugin_dep (GList ** list, GstPluginDep * dep)
+{
+ GstRegistryChunkDep *ed;
+ GstRegistryChunk *chk;
+ gchar **s;
+
+ ed = g_new0 (GstRegistryChunkDep, 1);
+ chk = gst_registry_chunks_make_data (ed, sizeof (GstRegistryChunkDep));
+
+ ed->flags = dep->flags;
+ ed->n_env_vars = 0;
+ ed->n_paths = 0;
+ ed->n_names = 0;
+
+ ed->env_hash = dep->env_hash;
+ ed->stat_hash = dep->stat_hash;
+
+ for (s = dep->env_vars; s != NULL && *s != NULL; ++s, ++ed->n_env_vars)
+ gst_registry_chunks_save_string (list, g_strdup (*s));
+
+ for (s = dep->paths; s != NULL && *s != NULL; ++s, ++ed->n_paths)
+ gst_registry_chunks_save_string (list, g_strdup (*s));
+
+ for (s = dep->names; s != NULL && *s != NULL; ++s, ++ed->n_names)
+ gst_registry_chunks_save_string (list, g_strdup (*s));
+
+ *list = g_list_prepend (*list, chk);
+
+ GST_LOG ("Saved external plugin dependency");
+ return TRUE;
+}
+
+/*
+ * _priv_gst_registry_chunks_save_plugin:
+ *
+ * Adapt a GstPlugin to our GstRegistryChunkPluginElement structure, and
+ * prepend it as a GstRegistryChunk in the provided list.
+ *
+ */
+gboolean
+_priv_gst_registry_chunks_save_plugin (GList ** list, GstRegistry * registry,
+ GstPlugin * plugin)
+{
+ GstRegistryChunkPluginElement *pe;
+ GstRegistryChunk *chk;
+ GList *plugin_features = NULL;
+ GList *walk;
+
+ pe = g_malloc0 (sizeof (GstRegistryChunkPluginElement));
+ chk =
+ gst_registry_chunks_make_data (pe,
+ sizeof (GstRegistryChunkPluginElement));
+
+ pe->file_size = plugin->file_size;
+ pe->file_mtime = plugin->file_mtime;
+ pe->nfeatures = 0;
+ pe->n_deps = 0;
+
+ /* pack external deps */
+ for (walk = plugin->priv->deps; walk != NULL; walk = walk->next) {
+ if (!gst_registry_chunks_save_plugin_dep (list, walk->data)) {
+ GST_ERROR ("Could not save external plugin dependency, aborting.");
+ goto fail;
+ }
+ ++pe->n_deps;
+ }
+
+ /* pack plugin features */
+ plugin_features =
+ gst_registry_get_feature_list_by_plugin (registry, plugin->desc.name);
+ for (walk = plugin_features; walk; walk = g_list_next (walk), pe->nfeatures++) {
+ GstPluginFeature *feature = GST_PLUGIN_FEATURE (walk->data);
+
+ if (!gst_registry_chunks_save_feature (list, feature)) {
+ GST_ERROR ("Can't fill plugin feature, aborting.");
+ goto fail;
+ }
+ }
+
+ gst_plugin_feature_list_free (plugin_features);
+
+ /* pack cache data */
+ if (plugin->priv->cache_data) {
+ gchar *cache_str = gst_structure_to_string (plugin->priv->cache_data);
+ gst_registry_chunks_save_string (list, cache_str);
+ } else {
+ gst_registry_chunks_save_const_string (list, "");
+ }
+
+ /* pack plugin element strings */
+ gst_registry_chunks_save_const_string (list, plugin->desc.origin);
+ gst_registry_chunks_save_const_string (list, plugin->desc.package);
+ gst_registry_chunks_save_const_string (list, plugin->desc.source);
+ gst_registry_chunks_save_const_string (list, plugin->desc.license);
+ gst_registry_chunks_save_const_string (list, plugin->desc.version);
+ gst_registry_chunks_save_const_string (list, plugin->filename);
+ gst_registry_chunks_save_const_string (list, plugin->desc.description);
+ gst_registry_chunks_save_const_string (list, plugin->desc.name);
+
+ *list = g_list_prepend (*list, chk);
+
+ GST_DEBUG ("Found %d features in plugin \"%s\"", pe->nfeatures,
+ plugin->desc.name);
+ return TRUE;
+
+ /* Errors */
+fail:
+ gst_plugin_feature_list_free (plugin_features);
+ g_free (chk);
+ g_free (pe);
+ return FALSE;
+}
+
+/*
+ * gst_registry_chunks_load_pad_template:
+ *
+ * Make a new GstStaticPadTemplate from current GstRegistryChunkPadTemplate
+ * structure.
+ *
+ * Returns: new GstStaticPadTemplate
+ */
+static gboolean
+gst_registry_chunks_load_pad_template (GstElementFactory * factory, gchar ** in,
+ gchar * end)
+{
+ GstRegistryChunkPadTemplate *pt;
+ GstStaticPadTemplate *template = NULL;
+
+ align (*in);
+ GST_DEBUG ("Reading/casting for GstRegistryChunkPadTemplate at address %p",
+ *in);
+ unpack_element (*in, pt, GstRegistryChunkPadTemplate, end, fail);
+
+ template = g_new0 (GstStaticPadTemplate, 1);
+ template->presence = pt->presence;
+ template->direction = pt->direction;
+
+ /* unpack pad template strings */
+ unpack_const_string (*in, template->name_template, end, fail);
+ unpack_string (*in, template->static_caps.string, end, fail);
+
+ __gst_element_factory_add_static_pad_template (factory, template);
+ GST_DEBUG ("Added pad_template %s", template->name_template);
+
+ return TRUE;
+fail:
+ GST_INFO ("Reading pad template failed");
+ g_free (template);
+ return FALSE;
+}
+
+/*
+ * gst_registry_chunks_load_feature:
+ *
+ * Make a new GstPluginFeature from current binary plugin feature structure
+ *
+ * Returns: new GstPluginFeature
+ */
+static gboolean
+gst_registry_chunks_load_feature (GstRegistry * registry, gchar ** in,
+ gchar * end, const gchar * plugin_name)
+{
+ GstRegistryChunkPluginFeature *pf = NULL;
+ GstPluginFeature *feature = NULL;
+ gchar *type_name = NULL, *str;
+ GType type;
+ guint i;
+
+ /* unpack plugin feature strings */
+ unpack_string (*in, type_name, end, fail);
+
+ if (G_UNLIKELY (!type_name)) {
+ GST_ERROR ("No feature type name");
+ return FALSE;
+ }
+
+ GST_DEBUG ("Plugin '%s' feature typename : '%s'", plugin_name, type_name);
+
+ if (G_UNLIKELY (!(type = g_type_from_name (type_name)))) {
+ GST_ERROR ("Unknown type from typename '%s' for plugin '%s'", type_name,
+ plugin_name);
+ g_free (type_name);
+ return FALSE;
+ }
+ if (G_UNLIKELY ((feature = g_object_new (type, NULL)) == NULL)) {
+ GST_ERROR ("Can't create feature from type");
+ g_free (type_name);
+ return FALSE;
+ }
+
+ if (G_UNLIKELY (!GST_IS_PLUGIN_FEATURE (feature))) {
+ GST_ERROR ("typename : '%s' is not a plugin feature", type_name);
+ goto fail;
+ }
+
+ /* unpack more plugin feature strings */
+ unpack_string (*in, feature->name, end, fail);
+
+ if (GST_IS_ELEMENT_FACTORY (feature)) {
+ GstRegistryChunkElementFactory *ef;
+ guint n;
+ GstElementFactory *factory = GST_ELEMENT_FACTORY_CAST (feature);
+
+ align (*in);
+ GST_LOG ("Reading/casting for GstRegistryChunkElementFactory at address %p",
+ *in);
+ unpack_element (*in, ef, GstRegistryChunkElementFactory, end, fail);
+ pf = (GstRegistryChunkPluginFeature *) ef;
+
+ /* unpack element factory strings */
+ unpack_string (*in, factory->details.longname, end, fail);
+ unpack_string (*in, factory->details.klass, end, fail);
+ unpack_string (*in, factory->details.description, end, fail);
+ unpack_string (*in, factory->details.author, end, fail);
+ n = ef->npadtemplates;
+ GST_DEBUG ("Element factory : '%s' with npadtemplates=%d",
+ factory->details.longname, n);
+
+ /* load pad templates */
+ for (i = 0; i < n; i++) {
+ if (G_UNLIKELY (!gst_registry_chunks_load_pad_template (factory, in,
+ end))) {
+ GST_ERROR ("Error while loading binary pad template");
+ goto fail;
+ }
+ }
+
+ /* load uritypes */
+ if (G_UNLIKELY ((n = ef->nuriprotocols))) {
+ GST_DEBUG ("Reading %d UriTypes at address %p", n, *in);
+
+ align (*in);
+ factory->uri_type = *((guint *) * in);
+ *in += sizeof (factory->uri_type);
+ /*unpack_element(*in, &factory->uri_type, factory->uri_type, end, fail); */
+
+ factory->uri_protocols = g_new0 (gchar *, n + 1);
+ for (i = 0; i < n; i++) {
+ unpack_string (*in, str, end, fail);
+ factory->uri_protocols[i] = str;
+ }
+ }
+ /* load interfaces */
+ if (G_UNLIKELY ((n = ef->ninterfaces))) {
+ GST_DEBUG ("Reading %d Interfaces at address %p", n, *in);
+ for (i = 0; i < n; i++) {
+ unpack_string (*in, str, end, fail);
+ __gst_element_factory_add_interface (factory, str);
+ g_free (str);
+ }
+ }
+ } else if (GST_IS_TYPE_FIND_FACTORY (feature)) {
+ GstRegistryChunkTypeFindFactory *tff;
+ GstTypeFindFactory *factory = GST_TYPE_FIND_FACTORY (feature);
+
+ align (*in);
+ GST_DEBUG
+ ("Reading/casting for GstRegistryChunkPluginFeature at address %p",
+ *in);
+ unpack_element (*in, tff, GstRegistryChunkTypeFindFactory, end, fail);
+ pf = (GstRegistryChunkPluginFeature *) tff;
+
+ /* load caps */
+ unpack_string (*in, str, end, fail);
+ factory->caps = (str && *str) ? gst_caps_from_string (str) : NULL;
+ g_free (str);
+ /* load extensions */
+ if (tff->nextensions) {
+ GST_DEBUG ("Reading %d Typefind extensions at address %p",
+ tff->nextensions, *in);
+ factory->extensions = g_new0 (gchar *, tff->nextensions + 1);
+ for (i = 0; i < tff->nextensions; i++) {
+ unpack_string (*in, str, end, fail);
+ factory->extensions[i] = str;
+ }
+ }
+ } else if (GST_IS_INDEX_FACTORY (feature)) {
+ GstIndexFactory *factory = GST_INDEX_FACTORY (feature);
+
+ align (*in);
+ GST_DEBUG
+ ("Reading/casting for GstRegistryChunkPluginFeature at address %p",
+ *in);
+ unpack_element (*in, pf, GstRegistryChunkPluginFeature, end, fail);
+
+ /* unpack index factory strings */
+ unpack_string (*in, factory->longdesc, end, fail);
+ } else {
+ GST_WARNING ("unhandled factory type : %s", G_OBJECT_TYPE_NAME (feature));
+ goto fail;
+ }
+
+ feature->rank = pf->rank;
+
+ /* should already be the interned string, but better make sure */
+ feature->plugin_name = g_intern_string (plugin_name);
+
+ gst_registry_add_feature (registry, feature);
+ GST_DEBUG ("Added feature %s", feature->name);
+
+ g_free (type_name);
+ return TRUE;
+
+ /* Errors */
+fail:
+ GST_INFO ("Reading plugin feature failed");
+ g_free (type_name);
+ if (feature) {
+ if (GST_IS_OBJECT (feature))
+ gst_object_unref (feature);
+ else
+ g_object_unref (feature);
+ }
+ return FALSE;
+}
+
+static gchar **
+gst_registry_chunks_load_plugin_dep_strv (gchar ** in, gchar * end, guint n)
+{
+ gchar **arr;
+
+ if (n == 0)
+ return NULL;
+
+ arr = g_new0 (gchar *, n + 1);
+ while (n > 0) {
+ unpack_string (*in, arr[n - 1], end, fail);
+ --n;
+ }
+ return arr;
+fail:
+ GST_INFO ("Reading plugin dependency strings failed");
+ return NULL;
+}
+
+static gboolean
+gst_registry_chunks_load_plugin_dep (GstPlugin * plugin, gchar ** in,
+ gchar * end)
+{
+ GstPluginDep *dep;
+ GstRegistryChunkDep *d;
+ gchar **s;
+
+ align (*in);
+ GST_LOG_OBJECT (plugin, "Unpacking GstRegistryChunkDep from %p", *in);
+ unpack_element (*in, d, GstRegistryChunkDep, end, fail);
+
+ dep = g_new0 (GstPluginDep, 1);
+
+ dep->env_hash = d->env_hash;
+ dep->stat_hash = d->stat_hash;
+
+ dep->flags = d->flags;
+
+ dep->names = gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_names);
+ dep->paths = gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_paths);
+ dep->env_vars =
+ gst_registry_chunks_load_plugin_dep_strv (in, end, d->n_env_vars);
+
+ plugin->priv->deps = g_list_append (plugin->priv->deps, dep);
+
+ GST_DEBUG_OBJECT (plugin, "Loaded external plugin dependency from registry: "
+ "env_hash: %08x, stat_hash: %08x", dep->env_hash, dep->stat_hash);
+ for (s = dep->env_vars; s != NULL && *s != NULL; ++s)
+ GST_LOG_OBJECT (plugin, " evar: %s", *s);
+ for (s = dep->paths; s != NULL && *s != NULL; ++s)
+ GST_LOG_OBJECT (plugin, " path: %s", *s);
+ for (s = dep->names; s != NULL && *s != NULL; ++s)
+ GST_LOG_OBJECT (plugin, " name: %s", *s);
+
+ return TRUE;
+fail:
+ GST_INFO ("Reading plugin dependency failed");
+ return FALSE;
+}
+
+
+/*
+ * _priv_gst_registry_chunks_load_plugin:
+ *
+ * Make a new GstPlugin from current GstRegistryChunkPluginElement structure
+ * and add it to the GstRegistry. Return an offset to the next
+ * GstRegistryChunkPluginElement structure.
+ */
+gboolean
+_priv_gst_registry_chunks_load_plugin (GstRegistry * registry, gchar ** in,
+ gchar * end, GstPlugin ** out_plugin)
+{
+ GstRegistryChunkPluginElement *pe;
+ GstPlugin *plugin = NULL;
+ gchar *cache_str = NULL;
+ guint i, n;
+
+ align (*in);
+ GST_LOG ("Reading/casting for GstRegistryChunkPluginElement at address %p",
+ *in);
+ unpack_element (*in, pe, GstRegistryChunkPluginElement, end, fail);
+
+ plugin = g_object_new (GST_TYPE_PLUGIN, NULL);
+
+ /* TODO: also set GST_PLUGIN_FLAG_CONST */
+ plugin->flags |= GST_PLUGIN_FLAG_CACHED;
+ plugin->file_mtime = pe->file_mtime;
+ plugin->file_size = pe->file_size;
+
+ /* unpack plugin element strings */
+ unpack_const_string (*in, plugin->desc.name, end, fail);
+ unpack_string (*in, plugin->desc.description, end, fail);
+ unpack_string (*in, plugin->filename, end, fail);
+ unpack_const_string (*in, plugin->desc.version, end, fail);
+ unpack_const_string (*in, plugin->desc.license, end, fail);
+ unpack_const_string (*in, plugin->desc.source, end, fail);
+ unpack_const_string (*in, plugin->desc.package, end, fail);
+ unpack_const_string (*in, plugin->desc.origin, end, fail);
+ GST_LOG ("read strings for name='%s'", plugin->desc.name);
+ GST_LOG (" desc.description='%s'", plugin->desc.description);
+ GST_LOG (" filename='%s'", plugin->filename);
+ GST_LOG (" desc.version='%s'", plugin->desc.version);
+ GST_LOG (" desc.license='%s'", plugin->desc.license);
+ GST_LOG (" desc.source='%s'", plugin->desc.source);
+ GST_LOG (" desc.package='%s'", plugin->desc.package);
+ GST_LOG (" desc.origin='%s'", plugin->desc.origin);
+
+ /* unpack cache data */
+ unpack_string (*in, cache_str, end, fail);
+ if (*cache_str) {
+ plugin->priv->cache_data = gst_structure_from_string (cache_str, NULL);
+ }
+ g_free (cache_str);
+
+ plugin->basename = g_path_get_basename (plugin->filename);
+
+ /* Takes ownership of plugin */
+ gst_registry_add_plugin (registry, plugin);
+ n = pe->nfeatures;
+ GST_DEBUG ("Added plugin '%s' plugin with %d features from binary registry",
+ plugin->desc.name, n);
+
+ /* Load plugin features */
+ for (i = 0; i < n; i++) {
+ if (G_UNLIKELY (!gst_registry_chunks_load_feature (registry, in, end,
+ plugin->desc.name))) {
+ GST_ERROR ("Error while loading binary feature");
+ gst_registry_remove_plugin (registry, plugin);
+ goto fail;
+ }
+ }
+
+ /* Load external plugin dependencies */
+ for (i = 0; i < pe->n_deps; ++i) {
+ if (G_UNLIKELY (!gst_registry_chunks_load_plugin_dep (plugin, in, end))) {
+ GST_ERROR_OBJECT (plugin, "Could not read external plugin dependency");
+ gst_registry_remove_plugin (registry, plugin);
+ goto fail;
+ }
+ }
+
+ if (out_plugin)
+ *out_plugin = plugin;
+
+ return TRUE;
+
+ /* Errors */
+fail:
+ GST_INFO ("Reading plugin failed");
+ return FALSE;
+}
--- /dev/null
+/* GStreamer
+ * Copyright (C) 2006 Josep Torra <josep@fluendo.com>
+ * Copyright (C) 2006 Mathieu Garcia <matthieu@fluendo.com>
+ * Copyright (C) 2006 Stefan Kost <ensonic@sonicpulse.de>
+ *
+ * gstregistrybinary.h: Header for registry handling
+ *
+ * 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.
+ */
+#ifndef __GST_REGISTRYCHUNKS_H__
+#define __GST_REGISTRYCHUNKS_H__
+
+#include <gst/gstpad.h>
+#include <gst/gstregistry.h>
+
+/*
+ * we reference strings directly from the plugins and in this case set CONST to
+ * avoid freeing them
+ */
+enum {
+ GST_REGISTRY_CHUNK_FLAG_NONE = 0,
+ GST_REGISTRY_CHUNK_FLAG_CONST = 1
+};
+
+/*
+ * GstRegistryChunk:
+ *
+ * Header for binary blobs
+ */
+typedef struct _GstRegistryChunk
+{
+ gpointer data;
+ guint size;
+ guint flags;
+ gboolean align;
+} GstRegistryChunk;
+
+/*
+ * GstRegistryChunkPluginElement:
+ *
+ * @n_deps: Says how many dependency structures follows.
+ *
+ * @nfeatures: says how many binary plugin feature structures we will have
+ * right after the structure itself.
+ *
+ * A structure containing (staticely) every information needed for a plugin
+ */
+
+typedef struct _GstRegistryChunkPluginElement
+{
+ gulong file_size;
+ gulong file_mtime;
+
+ guint n_deps;
+
+ guint nfeatures;
+} GstRegistryChunkPluginElement;
+
+/* GstRegistryChunkDep:
+ */
+typedef struct _GstRegistryChunkDep
+{
+ guint flags;
+ guint n_env_vars;
+ guint n_paths;
+ guint n_names;
+
+ guint env_hash;
+ guint stat_hash;
+} GstRegistryChunkDep;
+
+/*
+ * GstRegistryChunkPluginFeature:
+ * @rank: rank of the feature
+ *
+ * A structure containing the plugin features
+ */
+typedef struct _GstRegistryChunkPluginFeature
+{
+ gulong rank;
+} GstRegistryChunkPluginFeature;
+
+/*
+ * GstRegistryChunkElementFactory:
+ * @npadtemplates: stores the number of GstRegistryChunkPadTemplate structures
+ * following the structure
+ * @ninterfaces: stores the number of interface names following the structure
+ * @nuriprotocols: stores the number of protocol strings following the structure
+ *
+ * A structure containing the element factory fields
+ */
+typedef struct _GstRegistryChunkElementFactory
+{
+ GstRegistryChunkPluginFeature plugin_feature;
+
+ guint npadtemplates;
+ guint ninterfaces;
+ guint nuriprotocols;
+} GstRegistryChunkElementFactory;
+
+/*
+ * GstRegistryChunkTypeFindFactory:
+ * @nextensions: stores the number of typefind extensions
+ *
+ * A structure containing the element factory fields
+ */
+typedef struct _GstRegistryChunkTypeFindFactory
+{
+ GstRegistryChunkPluginFeature plugin_feature;
+
+ guint nextensions;
+} GstRegistryChunkTypeFindFactory;
+
+/*
+ * GstRegistryChunkPadTemplate:
+ *
+ * A structure containing the static pad templates of a plugin feature
+ */
+typedef struct _GstRegistryChunkPadTemplate
+{
+ guint direction; /* Either 0:"sink" or 1:"src" */
+ GstPadPresence presence;
+} GstRegistryChunkPadTemplate;
+
+G_BEGIN_DECLS
+
+gboolean
+_priv_gst_registry_chunks_save_plugin (GList ** list, GstRegistry * registry,
+ GstPlugin * plugin);
+
+gboolean
+_priv_gst_registry_chunks_load_plugin (GstRegistry * registry, gchar ** in,
+ gchar *end, GstPlugin **out_plugin);
+
+G_END_DECLS
+
+#endif /* __GST_REGISTRYCHUNKS_H__ */
endif
endif
+if GST_DISABLE_REGISTRY
+SUBDIRS_HELPERS =
+else
+SUBDIRS_HELPERS = helpers
+endif
+
SUBDIRS_ALWAYS = base controller dataprotocol
-SUBDIRS = $(SUBDIRS_ALWAYS) $(SUBDIRS_CHECK) $(SUBDIRS_NET)
-DIST_SUBDIRS = $(SUBDIRS_ALWAYS) check net
+SUBDIRS = $(SUBDIRS_ALWAYS) $(SUBDIRS_CHECK) $(SUBDIRS_NET) $(SUBDIRS_HELPERS)
+DIST_SUBDIRS = $(SUBDIRS_ALWAYS) check net helpers
--- /dev/null
+plugin-scanner
+*.o
--- /dev/null
+# helpers_PROGRAMS = plugin-scanner
+# FIXME: Subst helpersdir in configure.ac
+noinst_PROGRAMS = plugin-scanner
+
+plugin_scanner_SOURCES = plugin-scanner.c
+plugin_scanner_CFLAGS = $(GST_OBJ_CFLAGS)
+plugin_scanner_LDFLAGS = $(GST_OBJ_LIBS)
--- /dev/null
+/* GStreamer
+ * Copyright (C) 2008 Jan Schmidt <jan.schmidt@sun.com>
+ *
+ * plugin-scanner.c: tool to load plugins out of process for scanning
+ *
+ * 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.
+ *
+ * Helper binary that does plugin-loading out of process and feeds results
+ * back to the parent over fds.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <string.h>
+
+#include <gst/gst.h>
+#include <gst/gst_private.h>
+
+int
+main (int argc, char *argv[])
+{
+ gboolean res;
+ char **my_argv;
+ int my_argc;
+
+ if (argc != 2 || strcmp (argv[1], "-l"))
+ return 1;
+
+ if (!g_thread_supported ())
+ g_thread_init (NULL);
+
+ my_argc = 2;
+ my_argv = g_malloc (my_argc * sizeof (char *));
+ my_argv[0] = argv[0];
+ my_argv[1] = "--gst-disable-registry-update";
+
+#ifndef GST_DISABLE_REGISTRY
+ _gst_disable_registry_cache = TRUE;
+#endif
+
+ res = gst_init_check (&my_argc, &my_argv, NULL);
+
+ g_free (my_argv);
+ if (!res)
+ return 1;
+
+ /* Create registry scanner listener and run */
+ if (!_gst_plugin_loader_client_run ())
+ return 1;
+
+ return 0;
+}
return strcmp (name_a, name_b);
}
+static gint
+plugin_ptr_cmp (GstPlugin * a, GstPlugin * b)
+{
+ return (a == b) ? 0 : 1;
+}
static void
print_plugin (const gchar * marker, GstRegistry * registry, GstPlugin * plugin)
name = gst_plugin_get_name (plugin);
- GST_DEBUG ("%s: plugin %p %d %s", marker, plugin,
- GST_OBJECT_REFCOUNT (plugin), name);
+ GST_DEBUG ("%s: plugin %p %d %s file: %s", marker, plugin,
+ GST_OBJECT_REFCOUNT (plugin), name,
+ GST_STR_NULL (gst_plugin_get_filename (plugin)));
features = gst_registry_get_feature_list_by_plugin (registry, name);
for (f = features; f != NULL; f = f->next) {
GST_LOG (" -----------------------------------");
/* static plugins should have the same refcount as before (ie. 2), whereas
- * file-based plugins should have been replaced by a newly-created objects
- * (when reading the updated registry.xml file), so there should be only one
- * reference left for those, and that's ours */
+ * file-based plugins *may* have been replaced by a newly-created object
+ * if the on-disk file changed (and was not yet loaded). There should be
+ * only one reference left for those, and that's ours */
for (l = plugins_before; l; l = l->next) {
GstPlugin *plugin;
print_plugin ("before2", registry, plugin);
if (gst_plugin_get_filename (plugin)) {
- /* file-based plugin */
- ASSERT_OBJECT_REFCOUNT (plugin, "plugin", 1);
+ /* file-based plugin. */
+ ASSERT_OBJECT_REFCOUNT_BETWEEN (plugin, "plugin", 1, 2);
} else {
/* static plugin */
ASSERT_OBJECT_REFCOUNT (plugin, "plugin", 2);
plugins_after = gst_registry_get_plugin_list (registry);
for (l = plugins_after; l; l = l->next) {
- GstPlugin *plugin;
-
- plugin = GST_PLUGIN (l->data);
+ GstPlugin *plugin = GST_PLUGIN (l->data);
print_plugin ("after ", registry, plugin);
/* file-based plugins should have a refcount of 2 (one for the registry,
- * one for us for the list), static plugins should have one of 3 (one for
- * the registry, one for the new list and one for the old list).
+ * one for us for the list) or 3 (one for the registry, one for the before
+ * list, one for the after list), static plugins should have one of 3
+ * (one for the registry, one for the new list and one for the old list).
* This implicitly also makes sure that all static plugins are the same
- * objects as they were before and that all non-static ones have been
+ * objects as they were before. Non-static ones may or may not have been
* replaced by new objects */
if (gst_plugin_get_filename (plugin)) {
- ASSERT_OBJECT_REFCOUNT (plugin, "plugin", 2);
+ if (g_list_find_custom (plugins_before, plugin,
+ (GCompareFunc) plugin_ptr_cmp) != NULL) {
+ /* Same plugin existed in the before list. Refcount must be 3 */
+ ASSERT_OBJECT_REFCOUNT (plugin, "plugin", 3);
+ } else {
+ /* This plugin is newly created, so should only exist in the after list
+ * and the registry: Refcount must be 2 */
+ ASSERT_OBJECT_REFCOUNT (plugin, "plugin", 2);
+ }
} else {
ASSERT_OBJECT_REFCOUNT (plugin, "plugin", 3);
}
new_identity = gst_registry_lookup_feature (registry, "identity");
fail_unless (new_identity != NULL, "Can't find plugin feature 'identity'");
+#if 0
fail_unless (old_identity != new_identity, "Old and new 'identity' feature "
"should be different but are the same object");
ASSERT_OBJECT_REFCOUNT (old_identity, "old identity feature after update", 1);
+#endif
new_pipeline = gst_registry_lookup_feature (registry, "pipeline");
fail_unless (new_pipeline != NULL, "Can't find plugin feature 'pipeline'");
+#if 0
fail_unless (old_pipeline == new_pipeline, "Old and new 'pipeline' feature "
"objects should be the same, but are different objects");
+#endif
gst_plugin_list_free (plugins_before);
plugins_before = NULL;
_gst_debug_get_category
_gst_debug_nameof_funcptr
_gst_debug_register_funcptr
+ _gst_disable_registry_cache DATA
_gst_element_error_printf
_gst_elementclass_factory DATA
+ _gst_plugin_loader_client_run
_gst_plugin_register_static
_gst_trace_add_entry
_gst_trace_mutex DATA
projects / platform / upstream / gstreamer.git / commitdiff