gstreamer 0.90.6

data/ext/gstreamer/rbgstindexentry.c

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ *
+ * This file is part of Ruby/GStreamer.
+ *
+ * Ruby/GStreamer is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Ruby/GStreamer 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Ruby/GStreamer; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "rbgst.h"
+
+/* Class: Gst::IndexEntry
+ * An index's entry. 
+ */
+
+/*
+ * Method: data
+ *
+ * Gets the internal data stored in the entry.  The data depends of the type
+ * of the entry:
+ *	* Gst::IndexEntry::ID: the description of the ID, as a String. 
+ *	* Gst::IndexEntry::ASSOCIATION: an Array that contains the number of associations, a Gst::Format, the value of the format and the association flags (see Gst::Index::AssocFlags).
+ *	* Gst::IndexEntry::FORMAT: an Array that contains a Gst::Format and its value.
+ *	* Gst::IndexEntry::OBJECt: not yet implemented.
+ *
+ * Returns: the internal data of the entry. 
+ */
+static VALUE
+rb_gst_index_entry_get_data (VALUE self)
+{
+    GstIndexEntry *entry;
+    VALUE data;
+
+    entry = RGST_INDEX_ENTRY (self);
+    switch (entry->type) {
+    case GST_INDEX_ENTRY_ID:
+        data = CSTR2RVAL (entry->data.id.description);
+        break;
+
+    case GST_INDEX_ENTRY_ASSOCIATION:
+        data = rb_ary_new ();
+        rb_ary_push (data, INT2FIX (entry->data.assoc.nassocs));
+        rb_ary_push (data, RGST_FORMAT_NEW (entry->data.assoc.assocs->format));
+        rb_ary_push (data, ULL2NUM (entry->data.assoc.assocs->value));
+        rb_ary_push (data,
+                     GFLAGS2RVAL (entry->data.assoc.flags,
+                                  GST_TYPE_ASSOC_FLAGS));
+        break;
+
+    case GST_INDEX_ENTRY_FORMAT:
+        data = rb_ary_new ();
+        rb_ary_push (data, RGST_FORMAT_NEW (entry->data.format.format));
+        rb_ary_push (data, CSTR2RVAL (entry->data.format.key));
+        break;
+
+    case GST_INDEX_ENTRY_OBJECT:   /* TODO */
+    default:
+        data = Qnil;
+    }
+    return data;
+}
+
+/* Method: entry_type
+ * Returns: the type of the entry (see Gst::IndexEntry::Types).
+ */
+static VALUE
+rb_gst_index_entry_get_type (VALUE self)
+{
+    GstIndexEntry *entry = RGST_INDEX_ENTRY (self);
+
+    return GENUM2RVAL (entry->type, GST_TYPE_INDEX_ENTRY_TYPE);
+}
+
+void
+Init_gst_indexentry (void)
+{
+    VALUE c = G_DEF_CLASS (GST_TYPE_INDEX_ENTRY, "IndexEntry", mGst);
+
+    rb_undef_method (c, "initialize");
+    rb_define_method (c, "data", rb_gst_index_entry_get_data, 0);
+    rb_define_method (c, "entry_type", rb_gst_index_entry_get_type, 0);
+
+    G_DEF_CLASS (GST_TYPE_INDEX_ENTRY_TYPE, "Types", c);
+    G_DEF_CONSTANTS (c, GST_TYPE_INDEX_ENTRY_TYPE, "GST_INDEX_ENTRY_");
+}

data/ext/gstreamer/rbgstparse.c

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ *
+ * This file is part of Ruby/GStreamer.
+ *
+ * Ruby/GStreamer is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Ruby/GStreamer 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Ruby/GStreamer; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "rbgst.h"
+
+/* Module: Gst::Parse
+ * Parses command-line syntax into a pipeline. 
+ */
+
+/*
+ * Class method: launch(command)
+ * command: a command line.
+ *
+ * Creates a new pipeline based on command line syntax.
+ * On failure, an exception is thrown with a specific
+ * error message.   
+ *
+ * Returns: a reference to a new Gst::Bin on success,
+ * an exception on failure.
+ */
+static VALUE
+rb_gst_parse_launch (VALUE self, VALUE command)
+{
+#if !defined(GST_DISABLE_PARSE)
+	GError *error;
+	GstBin *bin;
+
+	error = NULL;
+	bin = (GstBin*)gst_parse_launch (RVAL2CSTR (command), &error);
+	if (bin != NULL)
+		return RGST_BIN_NEW (bin);
+        RAISE_GERROR(error);
+#else
+	rb_raise (rb_eRuntimeError, 
+		  "This function has been disabled "
+		  "when GStreamer was compiled");
+#endif
+	return Qnil;
+}
+
+void
+Init_gst_parse (void)
+{
+	VALUE c = rb_define_module_under (mGst, "Parse"); 
+	rb_define_module_function (c, "launch", rb_gst_parse_launch, 1);
+
+        G_DEF_ERROR(GST_PARSE_ERROR, "ParseError", mGst, rb_eRuntimeError,
+                    GST_TYPE_PARSE_ERROR);
+}

data/ext/gstreamer/rbgstquerytype.c

@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ *
+ * This file is part of Ruby/GStreamer.
+ *
+ * Ruby/GStreamer is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Ruby/GStreamer 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Ruby/GStreamer; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "rbgst.h"
+
+/* Class: Gst::QueryType
+ * Dynamically register new query types. 
+ */
+
+static GstQueryType *
+query_type_copy (const GstQueryType* query_type)
+{
+	GstQueryType *new_query_type;
+	g_return_val_if_fail (query_type != NULL, NULL);
+	new_query_type = g_new (GstQueryType, 1);
+	*new_query_type = *query_type;
+	return new_query_type;
+}
+
+GType
+gst_query_type_get_type2 (void)
+{
+	static GType our_type = 0;
+	if (our_type == 0)
+		our_type = g_boxed_type_register_static ("GstQueryTypeClass",
+			(GBoxedCopyFunc)query_type_copy,
+			(GBoxedFreeFunc)g_free);
+	return our_type;
+}
+
+/*
+ * Class method: find(nick)
+ * nick: the nick of an existing query type.
+ *
+ * Returns: a reference to the Gst::QueryType object registered with the 
+ * given nick, or nil if this query was not registered.
+ */
+static VALUE
+rb_gst_querytype_find (VALUE self, VALUE nick)
+{
+	GstQueryType type = gst_query_type_get_by_nick (RVAL2CSTR (nick));
+	return type != GST_QUERY_NONE 
+		? RGST_QUERY_TYPE_NEW (&type)
+		: Qnil; 
+}
+
+/*
+ * Class method: each { |query_type| block }
+ *
+ * Calls the block for each registered query type, passing a reference
+ * to the Gst::QueryType object as parameter.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rb_gst_querytype_each (VALUE self)
+{
+    GstIterator *iter;
+    gpointer value;
+
+    iter = gst_query_type_iterate_definitions();
+    while (gst_iterator_next(iter, &value) == GST_ITERATOR_OK) {
+        GstQueryTypeDefinition *definition = value;
+        rb_yield(RGST_QUERY_TYPE_NEW(&(definition->value)));
+    }
+    gst_iterator_free(iter);
+    return Qnil;
+}
+
+/* Method: type_id
+ * Returns: the type id of this query type (see Gst::QueryType::Type).
+ */
+static VALUE
+rb_gst_querytype_get_type_id (VALUE self)
+{
+	GstQueryType *querytype = RGST_QUERY_TYPE (self);
+	return INT2FIX (*querytype);
+}
+
+/* Method: nick
+ * Returns: the short nick of the query type.
+ */
+static VALUE
+rb_gst_querytype_get_nick (VALUE self)
+{
+	GstQueryType *querytype = RGST_QUERY_TYPE (self);
+	return CSTR2RVAL (gst_query_type_get_details (*querytype)->nick);
+}
+
+/* Method: description
+ * Returns: a longer description of the query type.
+ */
+static VALUE
+rb_gst_querytype_get_description (VALUE self)
+{
+	GstQueryType *querytype = RGST_QUERY_TYPE (self);
+	return CSTR2RVAL (gst_query_type_get_details (*querytype)->description);
+}
+
+/*
+ * Method: ==(query_type)
+ * query_type: a Gst::QueryType object.
+ *
+ * Checks if two Gst::QueryType objects are registered under the
+ * same nick.
+ *
+ * Returns: true on success, false on failure.
+ */
+static VALUE
+rb_gst_querytype_is_equal (VALUE self, VALUE other_query)
+{
+	GstQueryType *q1, *q2;
+	gchar *n1, *n2;
+
+	if (NIL_P (other_query))
+		return Qfalse;
+
+	q1 = RGST_QUERY_TYPE (self);
+	q2 = RGST_QUERY_TYPE (other_query);
+
+	n1 = gst_query_type_get_details (*q1)->nick;
+	n2 = gst_query_type_get_details (*q2)->nick;
+
+	return CBOOL2RVAL( strcmp (n1, n2) == 0);
+}
+
+void
+Init_gst_querytype (void)
+{
+	VALUE c = G_DEF_CLASS (GST_TYPE_QUERY_TYPE2, "QueryType", mGst);
+
+	rb_define_singleton_method (c, "each", rb_gst_querytype_each, 0);
+	rb_define_singleton_method (c, "find", rb_gst_querytype_find, 1);
+
+	rb_define_method (c, "type_id", rb_gst_querytype_get_type_id, 0);
+	rb_define_method (c, "nick", rb_gst_querytype_get_nick,	0);
+	rb_define_method (c, "description", rb_gst_querytype_get_description, 0);
+	rb_define_method (c, "==", rb_gst_querytype_is_equal, 1);
+
+	G_DEF_CLASS (GST_TYPE_QUERY_TYPE, "Type", c);
+	G_DEF_CONSTANTS (c, GST_TYPE_QUERY_TYPE, "GST_QUERY_");
+}

data/ext/gstreamer/rbgstregistry.c

@@ -0,0 +1,278 @@
+/*
+ * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ *
+ * This file is part of Ruby/GStreamer.
+ *
+ * Ruby/GStreamer is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Ruby/GStreamer 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Ruby/GStreamer; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "rbgst.h"
+
+/* Class: Gst::Registry
+ * Abstract class for managing plugins. 
+ */
+
+static VALUE
+rb_gst_registry_get_default(VALUE self)
+{
+    return RGST_REGISTRY_NEW(gst_registry_get_default());
+}
+
+/*
+ * Method: plugins
+ *
+ * Gets a list of all plugins in the pool.
+ *
+ * Returns: an array of Gst::Plugin objects.
+ */
+static VALUE
+rb_gst_registry_get_plugins(VALUE self)
+{
+    GList *list, *node;
+    VALUE arr;
+
+    arr = rb_ary_new();
+    list = gst_registry_get_plugin_list(RGST_REGISTRY(self));
+    for (node = list;
+         node != NULL;
+         node = g_list_next(node)) {
+        GstPlugin *plugin = (GstPlugin *)node->data;
+        rb_ary_push(arr, RGST_PLUGIN_NEW(plugin));
+    }
+    g_list_free(list);
+    return arr;
+}
+
+/*
+ * Method: each_plugin { |plugin| ... }
+ *
+ * Calls the block for each plugin in the pool, passing a reference to
+ * the Gst::Plugin as parameter.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rb_gst_registry_each_plugin (VALUE self)
+{
+	return rb_ary_yield (rb_gst_registry_get_plugins (self));
+}
+
+/*
+ * Method: get_features(feature_type_or_plugin_name)
+ * feature_type_or_plugin_name: a feature type or plugin name.
+ *
+ * Gets a list of all plugin features of the given type in the pool.
+ *
+ * Valid features types are Gst::AutoplugFactory, Gst::ElementFactory,
+ * Gst::IndexFactory, Gst::SchedulerFactory and Gst::TypeFactory.
+ *
+ * Returns: an array of Gst::PluginFeature objects.
+ */
+static VALUE
+rb_gst_registry_get_features(VALUE self, VALUE type_or_plugin_name)
+{
+    GList *list, *node;
+    GType gtype;
+    VALUE arr;
+
+    if (RVAL2CBOOL(rb_obj_is_kind_of(type_or_plugin_name, rb_cString))) {
+        list = gst_registry_get_feature_list_by_plugin(RGST_REGISTRY(self),
+                                                       RVAL2CSTR(type_or_plugin_name));
+    } else {
+        gtype = CLASS2GTYPE(type_or_plugin_name);
+        if (!is_valid_pluginfeature_type(gtype))
+            rb_raise (rb_eArgError, "Invalid feature type.");
+
+        list = gst_registry_get_feature_list(RGST_REGISTRY(self), gtype);
+    }
+
+    arr = rb_ary_new();
+    for (node = list; node != NULL; node = g_list_next(node)) {
+        rb_ary_push(arr, instanciate_pluginfeature(GST_PLUGIN_FEATURE(node->data)));
+    }
+    g_list_free (list);
+
+    return arr;
+}
+
+/*
+ * Method: each_feature(feature_type) { |plugin_feature| ... }
+ *
+ * Calls the block for each plugin features of the given type in the pool, 
+ * passing a reference to the Gst::PluginFeature as parameter.
+ *
+ * Valid features types are Gst::AutoplugFactory, Gst::ElementFactory,
+ * Gst::IndexFactory, Gst::SchedulerFactory and Gst::TypeFactory.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rb_gst_registry_each_feature (VALUE self, VALUE type)
+{
+	return rb_ary_yield (rb_gst_registry_get_features (self, type));
+}
+
+/*
+ * Method: paths
+ *
+ * Gets a list of paths of the registry.
+ *
+ * Returns: an array of strings.
+ */
+static VALUE
+rb_gst_registry_get_paths (VALUE self)
+{
+	GList *list;
+	VALUE arr;
+
+	arr = rb_ary_new ();
+	for (list = gst_registry_get_path_list (RGST_REGISTRY (self));
+	     list != NULL;
+	     list = g_list_next (list))
+		rb_ary_push (arr, CSTR2RVAL ((gchar *) list->data)); 
+	g_list_free (list);
+	return arr;
+}
+
+/*
+ * Method: each_path { |path| ... } 
+ *
+ * Calls the block for each path of the registry, passing a reference to
+ * the path (a String object) as parameter.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rb_gst_registry_each_path (VALUE self)
+{
+	return rb_ary_yield (rb_gst_registry_get_paths (self));
+}
+
+/*
+ * Method: add_path(path)
+ * path: a path (a String object).
+ *
+ * Add the given path to the registry. 
+ * The syntax of the path is specific to the registry. 
+ * If the path has already been added, do nothing.
+ *
+ * Returns: nil.
+ */
+static VALUE
+rb_gst_registry_add_path(VALUE self, VALUE path)
+{
+    gst_registry_add_path(RGST_REGISTRY(self), RVAL2CSTR(path));
+    return Qnil;
+}
+
+/*
+ * Method: add_plugin(plugin)
+ * plugin: a Gst::Plugin.
+ *
+ * Adds a plugin to the registry. The 'plugin-added' signal will be emitted.
+ *
+ * Returns: true on success, false otherwise.
+ */
+static VALUE
+rb_gst_registry_add_plugin(VALUE self, VALUE plugin)
+{
+    return CBOOL2RVAL(gst_registry_add_plugin(RGST_REGISTRY (self),
+                                              RGST_PLUGIN (plugin)));
+}
+
+/*
+ * Method: remove_plugin(plugin)
+ * plugin: a Gst::Plugin.
+ *
+ * Removes a plugin from the registry.
+ *
+ * Returns: self.
+ */
+static VALUE
+rb_gst_registry_remove_plugin (VALUE self, VALUE plugin)
+{
+	gst_registry_remove_plugin (RGST_REGISTRY (self),
+				    RGST_PLUGIN (plugin));
+	return self;
+}
+
+/*
+ * Method: find_plugin(name)
+ * name: a plugin name.
+ *  
+ * Finds the plugin with the given name in the registry.
+ *
+ * Returns: a reference to a Gst::Plugin object if found,
+ * otherwise returns nil.
+ */
+static VALUE
+rb_gst_registry_find_plugin (VALUE self, VALUE name)
+{
+	GstPlugin *plugin = gst_registry_find_plugin (RGST_REGISTRY (self),
+						      RVAL2CSTR (name));
+	return plugin != NULL
+		? RGST_PLUGIN_NEW (plugin)
+		: Qnil;
+}
+
+/*
+ * Method: find_feature(feature_name, feature_type)
+ * feature_name: a feature name.
+ * feature_type: a feature type.
+ * 
+ * Finds the plugin feature with the given name and type in the registry.
+ *
+ * Valid features types are Gst::AutoplugFactory, Gst::ElementFactory,
+ * Gst::IndexFactory, Gst::SchedulerFactory and Gst::TypeFactory.
+ *
+ * Returns: a reference to a Gst::PluginFeature on success, or nil if the
+ * named plugin feature is not found.
+ */
+static VALUE
+rb_gst_registry_find_feature(VALUE self, VALUE name, VALUE type)
+{
+	GstPluginFeature *feature;
+	GType gtype;
+	
+	gtype = CLASS2GTYPE (type);
+	if (!is_valid_pluginfeature_type (gtype))
+		rb_raise (rb_eArgError, "Invalid feature type.");
+	feature = gst_registry_find_feature (RGST_REGISTRY (self),
+					     RVAL2CSTR (name),
+					     gtype);
+	return feature != NULL
+		? instanciate_pluginfeature (feature)
+		: Qnil;
+}
+
+void
+Init_gst_registry (void)
+{
+	VALUE c = G_DEF_CLASS (GST_TYPE_REGISTRY, "Registry", mGst); 
+
+	rb_define_singleton_method(c, "default", rb_gst_registry_get_default, 0);
+	
+	rb_define_method(c, "plugins", rb_gst_registry_get_plugins, 0);
+	rb_define_method(c, "each_plugin", rb_gst_registry_each_plugin, 0);
+	rb_define_method(c, "get_features", rb_gst_registry_get_features, 1);
+	rb_define_method(c, "each_feature", rb_gst_registry_each_feature, 1);
+	rb_define_method(c, "paths", rb_gst_registry_get_paths, 0);
+	rb_define_method(c, "each_path", rb_gst_registry_each_path, 0);
+	rb_define_method(c, "add_path",	rb_gst_registry_add_path, 1);
+	rb_define_method(c, "add_plugin", rb_gst_registry_add_plugin, 1);
+	rb_define_method(c, "remove_plugin", rb_gst_registry_remove_plugin, 1);
+	rb_define_method(c, "find_plugin", rb_gst_registry_find_plugin, 1);
+	rb_define_method(c, "find_feature", rb_gst_registry_find_feature, 2);
+}