gstreamer 0.90.6

data/ext/gstreamer/rbgst-pipeline.c

@@ -0,0 +1,90 @@
+
+/*
+ * Copyright (C) 2008 Sjoerd Simons <sjoerd@luon.net>
+ * 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"
+
+#define SELF(obj) (RVAL2GST_PIPELINE(obj))
+
+/* Class: Gst::Pipeline
+ * In almost all cases, you'll want to use a Gst::Pipeline when creating a 
+ * filter graph. The Gst::Pipeline will manage all the scheduling issues, 
+ * including threading, as well as provide simple interfaces to common 
+ * functions, like 'Play'.
+ */
+
+/*
+ * Class method: new(name=nil)
+ * name: a name for the pipeline.
+ *
+ * Constructs a new Gst::Pipeline object.
+ *
+ * If element name is ommited (or nil), then the pipeline will receive a guaranteed
+ * unique name, consisting of the "pipeline" string and a number.
+ * If name is given, it will be given the name supplied.
+ *
+ * Returns: a newly constructed Gst::Pipeline.
+ */
+static VALUE
+rb_gst_pipeline_new (int argc, VALUE *argv, VALUE self)
+{
+	GstElement *bin;
+	VALUE name;
+
+	rb_scan_args (argc, argv, "01", &name);
+
+	bin = gst_pipeline_new (NIL_P (name) ? NULL : RVAL2CSTR(name));
+	if (bin != NULL)
+		RBGST_INITIALIZE (self, bin);
+	return Qnil;
+}
+
+static VALUE
+rb_gst_pipeline_get_bus(VALUE self)
+{
+    GstBus *bus;
+    VALUE ret;
+
+    bus = gst_pipeline_get_bus(SELF(self));
+    if (bus == NULL)
+      return Qnil;
+
+    ret = GST_BUS2RVAL_UNREF(bus);
+
+    /* Make the bus a child of the pipeline as their (minimum) livetimes are
+     * bound together.. A pipeline can potentially change it's bus though, but
+     * we have no way to catch that case */
+    G_CHILD_ADD(self, ret);
+
+    return ret;
+}
+
+void
+Init_gst_pipeline(void)
+{
+    VALUE cPipeline;
+
+    cPipeline = G_DEF_CLASS(GST_TYPE_PIPELINE, "Pipeline", mGst);
+
+    rb_define_method(cPipeline, "initialize", rb_gst_pipeline_new, -1);
+
+    rb_define_method(cPipeline, "bus", rb_gst_pipeline_get_bus, 0);
+}

data/ext/gstreamer/rbgst-plugin-feature.c

@@ -0,0 +1,134 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ * Copyright (C) 2007 Ruby-GNOME2 Project Team
+ *
+ * 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"
+
+#define SELF(self) RVAL2GST_PLUGIN_FEATURE(self)
+
+#define RVAL2GST_RANK(rank) RVAL2GENUM(rank, GST_TYPE_RANK)
+#define GST_RANK2RVAL(rank) GENUM2RVAL(rank, GST_TYPE_RANK)
+
+/* Class: Gst::PluginFeature
+ * This is a base class for anything that can be added to a Gst::Plugin.
+ */
+
+/* Method: name
+ * Returns: the name of the feature.
+ */
+static VALUE
+rb_gst_pluginfeature_get_name (VALUE self)
+{
+	GstPluginFeature *feature = RGST_PLUGIN_FEATURE (self);
+	return CSTR2RVAL (GST_PLUGIN_FEATURE_NAME (feature));
+}
+
+gboolean
+is_valid_pluginfeature_type (const GType type)
+{
+	return type == GST_TYPE_ELEMENT_FACTORY ||
+            type == GST_TYPE_INDEX_FACTORY;
+}
+
+VALUE
+instanciate_pluginfeature (GstPluginFeature *feature)
+{
+
+	if (GST_IS_ELEMENT_FACTORY (feature))
+		return RGST_ELEMENT_FACTORY_NEW (feature);
+	else if (GST_IS_INDEX_FACTORY (feature))
+		return RGST_INDEX_FACTORY_NEW (feature);
+	else if (GST_IS_TYPE_FIND_FACTORY (feature))
+		return RGST_TYPE_FIND_FACTORY_NEW (feature);
+	else
+		rb_raise(rb_eArgError,
+			 "Invalid plugin feature of type ``%s''",
+			 g_type_name (G_OBJECT_TYPE (feature))); 
+	return Qnil;
+}
+
+static VALUE
+load_bang(VALUE self)
+{
+    GstPluginFeature *original, *feature;
+
+    original = SELF(self);
+    feature = gst_plugin_feature_load(original);
+    if (feature) {
+        if (feature != original)
+            G_INITIALIZE(self, feature);
+        gst_object_unref(original);
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE
+loaded_p(VALUE self)
+{
+    return CBOOL2RVAL(SELF(self)->loaded);
+}
+
+static VALUE
+get_rank(VALUE self)
+{
+    return GST_RANK2RVAL(gst_plugin_feature_get_rank(SELF(self)));
+}
+
+static VALUE
+set_rank(VALUE self, VALUE rank)
+{
+    gst_plugin_feature_set_rank(SELF(self), RVAL2GST_RANK(rank));
+    return Qnil;
+}
+
+static VALUE
+get_plugin_name(VALUE self)
+{
+    return CSTR2RVAL(SELF(self)->plugin_name);
+}
+
+
+void
+Init_gst_plugin_feature (void)
+{
+    VALUE rb_cGstPluginFeature;
+
+    rb_cGstPluginFeature = G_DEF_CLASS(GST_TYPE_PLUGIN_FEATURE,
+                                       "PluginFeature", mGst);
+
+    G_DEF_CLASS(GST_TYPE_RANK, "Rank", mGst);
+    G_DEF_CONSTANTS(mGst, GST_TYPE_RANK, "GST_");
+
+    rb_define_method(rb_cGstPluginFeature, "name",
+                     rb_gst_pluginfeature_get_name, 0);
+
+    rb_define_method(rb_cGstPluginFeature, "load!", load_bang, 0);
+    rb_define_method(rb_cGstPluginFeature, "loaded?", loaded_p, 0);
+
+    rb_define_method(rb_cGstPluginFeature, "rank", get_rank, 0);
+    rb_define_method(rb_cGstPluginFeature, "set_rank", set_rank, 1);
+
+    rb_define_method(rb_cGstPluginFeature, "plugin_name", get_plugin_name, 0);
+
+    G_DEF_SETTERS(rb_cGstPluginFeature);
+}

data/ext/gstreamer/rbgst-plugin.c

@@ -0,0 +1,164 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ * Copyright (C) 2007 Ruby-GNOME2 Project Team
+ *
+ * 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"
+
+#define SELF(self) RVAL2GST_PLUGIN(self)
+
+/* Class: Gst::Plugin
+ * Dynamically loadable Elements 
+ */
+
+/* Method: loaded?
+ * Returns: true if the plugin is loaded into memory, false otherwise.
+ */
+static VALUE
+rb_gst_plugin_is_loaded (VALUE self)
+{
+	GstPlugin *plugin = RGST_PLUGIN (self);
+	return CBOOL2RVAL (gst_plugin_is_loaded (plugin));
+}
+
+/* Method: filename
+ * Returns: the filename where this plugin comes from.
+ */
+static VALUE
+rb_gst_plugin_get_filename (VALUE self)
+{
+	return CSTR2RVAL (gst_plugin_get_filename (RGST_PLUGIN (self)));
+}
+
+/* Method: description 
+ * Returns: a long description of the plugin.
+ */
+static VALUE
+rb_gst_plugin_get_description (VALUE self)
+{
+	return CSTR2RVAL (gst_plugin_get_description (RGST_PLUGIN (self)));
+}
+
+/* Method: package 
+ * Returns: the name of the package this plugin belongs to.
+ */
+static VALUE
+rb_gst_plugin_get_package (VALUE self)
+{
+	return CSTR2RVAL (gst_plugin_get_package (RGST_PLUGIN (self)));
+}
+
+/* Method: license 
+ * Returns: the effective license of the plugin.
+ */
+static VALUE
+rb_gst_plugin_get_license (VALUE self)
+{
+	return CSTR2RVAL (gst_plugin_get_license (RGST_PLUGIN (self)));
+}
+
+static VALUE
+get_source (VALUE self)
+{
+    return CSTR2RVAL(gst_plugin_get_source(SELF(self)));
+}
+
+/* Method: origin
+ * Returns: the URL to the provider of the plugin.
+ */
+static VALUE
+rb_gst_plugin_get_origin (VALUE self)
+{
+	return CSTR2RVAL (gst_plugin_get_origin ( RGST_PLUGIN (self)));
+}
+
+/* Method: name 
+ * Returns: the unique name of the plugin.
+ */
+static VALUE
+rb_gst_plugin_get_name (VALUE self)
+{
+	return CSTR2RVAL (gst_plugin_get_name (RGST_PLUGIN (self)));
+}
+
+/* Method: minor_version 
+ * Returns: the minor version of the core this plugin was compiled for.
+ */
+static VALUE
+rb_gst_plugin_get_minor_version (VALUE self)
+{
+	return INT2FIX (RGST_PLUGIN (self)->desc.minor_version);
+}
+
+/* Method: major_version 
+ * Returns: the major version of the core this plugin was compiled for.
+ */
+static VALUE
+rb_gst_plugin_get_major_version (VALUE self)
+{
+	return INT2FIX (RGST_PLUGIN (self)->desc.major_version);
+}
+
+/* Method: version
+ * Returns: the version of the plugin (note: as a string).
+ */
+static VALUE
+rb_gst_plugin_get_version (VALUE self)
+{
+	return CSTR2RVAL (RGST_PLUGIN (self)->desc.version);
+}
+
+/* Method: ==(plugin)
+ * Returns: true if two Gst::Plugin objects are refered by the same file,
+ * false otherwise.
+ */
+static VALUE
+rb_gst_plugin_is_equal (VALUE self, VALUE other_plugin)
+{
+	return NIL_P (other_plugin)
+		? Qfalse
+		: rb_equal (rb_gst_plugin_get_filename (self),
+			    rb_gst_plugin_get_filename (other_plugin));
+}
+
+void
+Init_gst_plugin (void)
+{
+    VALUE rb_cGstPlugin;
+
+    rb_cGstPlugin = G_DEF_CLASS(GST_TYPE_PLUGIN, "Plugin", mGst);
+
+    rb_define_method(rb_cGstPlugin, "loaded?", rb_gst_plugin_is_loaded, 0);
+    rb_define_method(rb_cGstPlugin, "==", rb_gst_plugin_is_equal, 1);
+
+    rb_define_method(rb_cGstPlugin, "filename", rb_gst_plugin_get_filename, 0);
+    rb_define_method(rb_cGstPlugin, "major_version",
+                     rb_gst_plugin_get_major_version, 0);
+    rb_define_method(rb_cGstPlugin, "minor_version",
+                     rb_gst_plugin_get_minor_version, 0);
+    rb_define_method(rb_cGstPlugin, "name", rb_gst_plugin_get_name, 0);
+    rb_define_method(rb_cGstPlugin, "description",
+                     rb_gst_plugin_get_description, 0);
+    rb_define_method(rb_cGstPlugin, "version", rb_gst_plugin_get_version, 0);
+    rb_define_method(rb_cGstPlugin, "license", rb_gst_plugin_get_license, 0);
+    rb_define_method(rb_cGstPlugin, "source", get_source, 0);
+    rb_define_method(rb_cGstPlugin, "package", rb_gst_plugin_get_package, 0);
+    rb_define_method(rb_cGstPlugin, "origin", rb_gst_plugin_get_origin, 0);
+}

data/ext/gstreamer/rbgst-private.c

@@ -0,0 +1,89 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * Copyright (C) 2008 Ruby-GNOME2 Project Team
+ *
+ * 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"
+#include "rbgst-private.h"
+
+char *
+_rbgst_inspect(VALUE object)
+{
+    VALUE inspected;
+    inspected = rb_funcall(object, rb_intern("inspect"), 0);
+    return StringValueCStr(inspected);
+}
+
+void
+_rbgst_define_class_if_need(VALUE klass, GType type, const gchar *prefix)
+{
+    VALUE parent;
+    const gchar *type_name;
+    gchar *class_name = NULL;
+    static ID id_gtype = 0;
+
+    if (rb_class2name(klass)[0] != '#')
+        return;
+
+    type_name = g_type_name(type);
+    if (g_str_has_prefix(type_name, "Gst"))
+        type_name += 3;
+
+    if (prefix)
+        class_name = g_strconcat(prefix, type_name, NULL);
+    G_DEF_CLASS(type, class_name ? class_name : type_name, mGst);
+    g_free(class_name);
+
+    parent = rb_ary_entry(rb_mod_ancestors(klass), 1);
+    if (!id_gtype)
+        id_gtype = rb_intern("gtype");
+    if (rb_respond_to(parent, id_gtype))
+        _rbgst_define_class_if_need(parent, CLASS2GTYPE(parent), prefix);
+}
+
+VALUE
+_rbgst_collect_elements(GstIterator *iter)
+{
+    VALUE elements;
+    gboolean done = FALSE;
+
+    elements = rb_ary_new();
+    while (!done) {
+        gpointer element;
+        switch (gst_iterator_next(iter, &element)) {
+          case GST_ITERATOR_OK:
+            rb_ary_push(elements, GST_ELEMENT2RVAL(element));
+            gst_object_unref(element);
+            break;
+          case GST_ITERATOR_RESYNC:
+            gst_iterator_resync(iter);
+            break;
+          case GST_ITERATOR_ERROR:
+            done = TRUE;
+            break;
+          case GST_ITERATOR_DONE:
+            done = TRUE;
+            break;
+        }
+    }
+    gst_iterator_free(iter);
+
+    return elements;
+}
+