gstreamer 0.90.6

data/ext/gstreamer/rbgst-mini-object.c

@@ -0,0 +1,220 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
+/*
+ * 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"
+#include "rbgst-private.h"
+
+/* Class: Gst::MiniObject
+ * Base class for refcounted lightweight objects.
+ */
+
+#define SELF(object) (RVAL2GST_MINI_OBJ(object))
+#define RVAL2GST_FLAGS(flags) \
+    (RVAL2GFLAGS(flags, GST_TYPE_MINI_OBJECT_FLAGS))
+#define GST_FLAGS2RVAL(flags) \
+    (GFLAGS2RVAL(flags, GST_TYPE_MINI_OBJECT_FLAGS))
+
+VALUE rb_cGstMiniObject;
+
+static RGConvertTable table = {0};
+
+void
+_rbgst_mini_object_free(void *ptr)
+{
+    if (ptr) {
+        gst_mini_object_unref((GstMiniObject *)ptr);
+    }
+}
+
+static VALUE
+rbgst_mini_object_get_superclass(void)
+{
+    return rb_cObject;
+}
+
+static VALUE
+initialize_with_abstract_check(int argc, VALUE *argv, VALUE self)
+{
+    GType gtype = CLASS2GTYPE(CLASS_OF(self));
+
+    if (G_TYPE_IS_ABSTRACT(gtype))
+        rb_raise(rb_eTypeError, "initializing abstract class");
+
+    return rb_call_super(argc, argv);
+}
+
+static void
+rbgst_mini_object_type_init_hook(VALUE klass)
+{
+    if (G_TYPE_IS_ABSTRACT(CLASS2GTYPE(klass)))
+        rb_define_method(klass, "initialize",
+                         initialize_with_abstract_check, -1);
+}
+
+static VALUE
+gvalue2rvalue(const GValue *value)
+{
+    GstMiniObject* obj;
+    obj = gst_value_get_mini_object(value);
+    return obj ? GOBJ2RVAL(obj) : Qnil;
+}
+
+static void
+rvalue2gvalue(VALUE value, GValue *result)
+{
+    gst_value_set_mini_object(result, NIL_P(value) ? NULL : RVAL2GOBJ(value));
+}
+
+static void
+rbgst_mini_object_initialize(VALUE object, gpointer instance)
+{
+    DATA_PTR(object) = instance;
+}
+
+static gpointer
+rbgst_mini_object_robj2instance(VALUE object)
+{
+    gpointer instance;
+
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGstMiniObject))) {
+        rb_raise(rb_eTypeError, "not a Gst::MiniObject");
+    }
+    Data_Get_Struct(object, GstMiniObject, instance);
+    return instance;
+}
+
+static void
+rbgst_mini_object_define_class_if_need(VALUE klass, GType type)
+{
+    _rbgst_define_class_if_need(klass, type, NULL);
+}
+
+static VALUE
+rbgst_mini_object_instance2robj(gpointer instance)
+{
+    VALUE klass;
+    GType type;
+
+    type = G_TYPE_FROM_INSTANCE(instance);
+    klass = GTYPE2CLASS(type);
+    rbgst_mini_object_define_class_if_need(klass, type);
+    gst_mini_object_ref(instance);
+    return Data_Wrap_Struct(klass, NULL, _rbgst_mini_object_free, instance);
+}
+
+static void
+rbgst_mini_object_unref(gpointer instance)
+{
+    gst_mini_object_unref(instance);
+}
+
+static VALUE
+s_allocate(VALUE klass)
+{
+    return Data_Wrap_Struct(klass, NULL, _rbgst_mini_object_free, NULL);
+}
+
+static VALUE
+get_flags(VALUE self)
+{
+    return GST_FLAGS2RVAL(GST_MINI_OBJECT_FLAGS(SELF(self)));
+}
+
+static VALUE
+set_flags(VALUE self, VALUE flag)
+{
+    GST_MINI_OBJECT_FLAGS(SELF(self)) = RVAL2GST_FLAGS(flag);
+    return Qnil;
+}
+
+static VALUE
+raise_flag(VALUE self, VALUE flag)
+{
+    GST_MINI_OBJECT_FLAG_SET(SELF(self), RVAL2GST_FLAGS(flag));
+    return Qnil;
+}
+
+static VALUE
+lower_flag(VALUE self, VALUE flag)
+{
+    GST_MINI_OBJECT_FLAG_UNSET(SELF(self), RVAL2GST_FLAGS(flag));
+    return Qnil;
+}
+
+static VALUE
+flag_raised_p(VALUE self, VALUE flag)
+{
+    return CBOOL2RVAL(GST_MINI_OBJECT_FLAG_IS_SET(SELF(self),
+                                                  RVAL2GST_FLAGS(flag)));
+}
+
+static VALUE
+writable_p(VALUE self)
+{
+    return CBOOL2RVAL(gst_mini_object_is_writable(SELF(self)));
+}
+
+static VALUE
+writable_bang(VALUE self)
+{
+    GstMiniObject *original, *writable;
+
+    original = SELF(self);
+    writable = gst_mini_object_make_writable(original);
+    DATA_PTR(self) = writable;
+    if (original == writable)
+        gst_mini_object_unref(original);
+    return self;
+}
+
+void
+Init_gst_mini_object(void)
+{
+    table.type = GST_TYPE_MINI_OBJECT;
+    table.get_superclass = rbgst_mini_object_get_superclass;
+    table.type_init_hook = rbgst_mini_object_type_init_hook;
+    table.rvalue2gvalue = rvalue2gvalue;
+    table.gvalue2rvalue = gvalue2rvalue;
+    table.initialize = rbgst_mini_object_initialize;
+    table.robj2instance = rbgst_mini_object_robj2instance;
+    table.instance2robj = rbgst_mini_object_instance2robj;
+    table.unref = rbgst_mini_object_unref;
+
+    RG_DEF_CONVERSION(&table);
+
+    rb_cGstMiniObject = G_DEF_CLASS(GST_TYPE_MINI_OBJECT, "MiniObject", mGst);
+
+    G_DEF_CLASS(GST_TYPE_MINI_OBJECT_FLAGS, "Flags", rb_cGstMiniObject);
+    G_DEF_CONSTANTS(rb_cGstMiniObject, GST_TYPE_MINI_OBJECT_FLAGS,
+                    "GST_MINI_OBJECT_");
+
+    rb_define_alloc_func(rb_cGstMiniObject, s_allocate);
+
+    rb_define_method(rb_cGstMiniObject, "flags", get_flags, 0);
+    rb_define_method(rb_cGstMiniObject, "set_flags", set_flags, 1);
+    rb_define_method(rb_cGstMiniObject, "raise_flag", raise_flag, 1);
+    rb_define_method(rb_cGstMiniObject, "lower_flag", lower_flag, 1);
+    rb_define_method(rb_cGstMiniObject, "flag_raised?", flag_raised_p, 1);
+    rb_define_method(rb_cGstMiniObject, "writable?", writable_p, 0);
+    rb_define_method(rb_cGstMiniObject, "writable!", writable_bang, 0);
+
+    G_DEF_SETTERS(rb_cGstMiniObject);
+}

data/ext/gstreamer/rbgst-object.c

@@ -0,0 +1,81 @@
+/* -*- 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"
+#include "rbgprivate.h"
+
+#define SELF(self) (RVAL2GST_OBJ(self))
+
+static RGConvertTable table = {0};
+
+/* Class: Gst::Object
+ * Basis for the GST object hierarchy.
+ */
+
+VALUE
+rbgst_object_instance2robj(gpointer instance)
+{
+    if (GST_OBJECT_IS_FLOATING(instance)) {
+        gst_object_ref(instance);
+        gst_object_sink(instance);
+    }
+
+    return rbgobj_get_ruby_object_from_gobject(instance, TRUE);
+}
+
+void
+rbgst_object_initialize(VALUE obj, gpointer cobj)
+{
+    if (GST_OBJECT_IS_FLOATING(cobj)) {
+        gst_object_ref(cobj);
+        gst_object_sink(cobj);
+    }
+
+    rbgobj_gobject_initialize(obj, cobj);
+}
+
+static VALUE
+object_set_name(VALUE self, VALUE name)
+{
+    return CBOOL2RVAL(gst_object_set_name(SELF(self), RVAL2CSTR(name)));
+}
+
+void
+Init_gst_object(void)
+{
+    VALUE cGstObject;
+
+    table.type = GST_TYPE_OBJECT;
+    table.instance2robj = rbgst_object_instance2robj;
+    table.initialize = rbgst_object_initialize;
+
+    RG_DEF_CONVERSION(&table);
+
+    cGstObject = G_DEF_CLASS(GST_TYPE_OBJECT, "Object", mGst);
+
+    rb_define_method(cGstObject, "set_name", object_set_name, 1);
+
+    G_DEF_SETTERS(cGstObject);
+
+    G_DEF_CLASS(GST_TYPE_OBJECT_FLAGS, "Flags", cGstObject);
+    G_DEF_CONSTANTS(cGstObject, GST_TYPE_OBJECT_FLAGS, "GST_");
+}

data/ext/gstreamer/rbgst-pad-template.c

@@ -0,0 +1,124 @@
+/* -*- 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_PAD_TEMPLATE(self)
+
+/* Class: Gst::PadTemplate
+ * Describe the media type of a Gst::Pad.
+ */
+
+/*
+ * Method: name
+ *
+ * Gets the name of the pad template.
+ * This overrides Gst::Object#name.
+ *
+ * Returns: the name of the pad template.
+ */
+static VALUE
+get_name(VALUE self)
+{
+    /*
+     *  We can't call Gst::Object#name since the real name
+     *  of the pad template is in the "name_template" field of
+     *  GstPadTemplate.
+     */
+    return CSTR2RVAL(GST_PAD_TEMPLATE_NAME_TEMPLATE(SELF(self)));
+}
+
+/* Method: presence
+ * Returns: the pad's presence (see Gst::Pad::Presence).
+ */
+static VALUE
+get_presence(VALUE self)
+{
+    return GENUM2RVAL(GST_PAD_TEMPLATE_PRESENCE(SELF(self)),
+                      GST_TYPE_PAD_PRESENCE);
+}
+
+/* Method: direction
+ * Returns: the pad's direction (see Gst::Pad::Direction).
+ */
+static VALUE
+get_direction(VALUE self)
+{
+    return GENUM2RVAL(GST_PAD_TEMPLATE_DIRECTION(SELF(self)),
+                      GST_TYPE_PAD_DIRECTION);
+}
+
+/*
+ * Method: caps
+ *
+ * Gets the capabilities of the pad template element.
+ *
+ * Returns: a Gst::Caps object.
+ */
+static VALUE
+get_caps(VALUE self)
+{
+    return GST_CAPS2RVAL(gst_pad_template_get_caps(RGST_PAD_TEMPLATE(self)));
+}
+
+/*
+ * Method: each_caps { |caps| ... }
+ *
+ * Calls the block for each capability of the pad template,
+ * passing a reference to the Gst::Caps object as parameter.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+each_caps(VALUE self)
+{
+    return rb_ary_yield(get_caps(self));
+}
+
+/* Method: has_caps?
+ * Returns: true if the pad template has capabilities, false otherwise.
+ */
+static VALUE
+has_caps_p(VALUE self)
+{
+    return CBOOL2RVAL(SELF(self)->caps != NULL);
+}
+
+void
+Init_gst_pad_template (void)
+{
+    VALUE cGstPadTemplate;
+
+    cGstPadTemplate = G_DEF_CLASS(GST_TYPE_PAD_TEMPLATE, "PadTemplate", mGst);
+
+    rb_define_method(cGstPadTemplate, "name", get_name, 0);
+    rb_define_method(cGstPadTemplate, "presence", get_presence, 0);
+    rb_define_method(cGstPadTemplate, "direction", get_direction, 0);
+    rb_define_method(cGstPadTemplate, "caps", get_caps, 0);
+    rb_define_method(cGstPadTemplate, "each_caps", each_caps, 0);
+    rb_define_method(cGstPadTemplate, "has_caps?", has_caps_p, 0);
+    rb_define_alias(cGstPadTemplate, "have_caps?", "has_caps?");
+
+    G_DEF_CLASS(GST_TYPE_PAD_TEMPLATE_FLAGS, "Flags", cGstPadTemplate);
+    G_DEF_CONSTANTS(cGstPadTemplate, GST_TYPE_PAD_TEMPLATE_FLAGS,
+                    "GST_PAD_TEMPLATE_");
+}

data/ext/gstreamer/rbgst-pad.c

@@ -0,0 +1,338 @@
+/*
+ * Copyright (C) 2003, 2004 Laurent Sansonetti <lrz@gnome.org>
+ * Copyright (C) 2006, 2008 Sjoerd Simons <sjoerd@luon.net>
+ * 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"
+
+#define SELF(self) RVAL2GST_PAD(self)
+
+static VALUE cGstPad;
+
+/* Class: Gst::Pad
+ * The link between Gst::Element objects.
+ */
+
+/* Method: name
+ * Returns: the pad's name.
+ */
+
+static VALUE
+rb_gst_pad_get_name (VALUE self)
+{
+	GstPad *pad = RGST_PAD (self);
+	return CSTR2RVAL (gst_pad_get_name (pad));
+}
+
+/* Method: direction
+ * Returns: the pad's direction (see Gst::Pad::Direction).
+ */
+
+static VALUE
+rb_gst_pad_get_direction (VALUE self)
+{
+	GstPad *pad = RGST_PAD (self);
+	return GENUM2RVAL (GST_PAD_DIRECTION(pad), GST_TYPE_PAD_DIRECTION);
+}
+
+/* Method: pad_template
+ * Returns: the Gst::PadTemplate object of this pad.
+ */
+static VALUE
+rb_gst_pad_get_pad_template(VALUE self)
+{
+	GstPadTemplate *templ = gst_pad_get_pad_template (RGST_PAD (self));
+	if (templ != NULL) {
+		gst_object_ref (GST_OBJECT (templ));
+		return RGST_PAD_TEMPLATE_NEW (templ);
+	}   
+	return Qnil;
+}
+
+/*
+ * Method: provides_query_types?
+ *
+ * Checks if the pad supports query types not handled by
+ * the default query types dispatcher.
+ *
+ * Returns: true if supported, false otherwise.
+ */
+static VALUE
+rb_gst_pad_provides_query_types (VALUE self)
+{
+	GstPad *pad = RGST_PAD (self);
+	return CBOOL2RVAL (GST_PAD_QUERYTYPEFUNC (pad) != gst_pad_get_query_types_default);
+}
+
+/*
+ * Method: query_types
+ *
+ * Gets a list of supported queries that can be performed on the pad.
+ *
+ * Returns: an array of Gst::QueryType objects.
+ */
+static VALUE
+rb_gst_pad_get_query_types (VALUE self)
+{
+	const GstQueryType *types; 
+	VALUE arr;
+
+	arr = rb_ary_new ();
+	types = gst_pad_get_query_types (RGST_PAD (self));
+	
+	while (types && *types) {
+		rb_ary_push (arr, RGST_QUERY_TYPE_NEW ((GstQueryType *)types));
+		types++;
+	}
+	return arr;
+}
+
+/*
+ * Method: each_query_type { |query_type| ... } 
+ *
+ * Calls the block for each supported query from the pad, passing
+ * a reference to the Gst::QueryType object as parameter.
+ *
+ * Returns: always nil.
+ */
+static VALUE
+rb_gst_pad_each_query_type (VALUE self)
+{
+	return rb_ary_yield (rb_gst_pad_get_query_types (self));
+}
+
+static VALUE
+rb_gst_pad_is_linked(VALUE self)
+{
+    return CBOOL2RVAL(gst_pad_is_linked(SELF(self)));
+}
+
+static GstPadLinkReturn
+rb_gst_pad_link_raw(VALUE self, VALUE other_pad)
+{
+    GstPad *src_pad;
+    GstPad *sink_pad;
+
+    src_pad = SELF(self);
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(other_pad, cGstPad))) {
+        rb_raise(rb_eTypeError, "Not a Gst::Pad");
+    }
+
+    sink_pad = RVAL2GST_PAD(other_pad);
+    return gst_pad_link(src_pad, sink_pad);
+}
+
+/*
+ * Method: link(other_pad)
+ * other_pad: a Gst::Pad.
+ *
+ * Links the current pad (source) to an other pad (sink).
+ *
+ * Returns: a Gst::Pad::LinkReturn
+ */
+static VALUE
+rb_gst_pad_link(VALUE self, VALUE other_pad)
+{
+    return GENUM2RVAL(rb_gst_pad_link_raw(self, other_pad),
+                      GST_TYPE_PAD_LINK_RETURN);
+}
+
+/*
+ * Method: >> other_pad
+ * other_pad: a Gst::Pad.
+ *
+ * Links the current pad (source) to an other pad (sink).
+ *
+ * Returns: the destination pad, or nil if the link failed.
+ *          (I can't understand why the return value is
+ *          useful. Because I can't write like the
+ *          following:
+ *            element1["src"] >> element2["sink"] >> element2["src"] >> element3["sink"]
+ *          I need to write like the following:
+ *            element1["src"] >> element2["sink"]
+ *            element2["src"] >> element3["sink"]
+ *          Return values aren't used in this case.)
+ */
+static VALUE
+rb_gst_pad_link_shift(VALUE self, VALUE other_pad)
+{
+    if (rb_gst_pad_link_raw(self, other_pad) == GST_PAD_LINK_OK)
+        return other_pad;
+    else
+        return Qnil;
+}
+
+/*
+ * Method: unlink(other_pad)
+ * other_pad: a Gst::Pad.
+ *
+ * Unlinks the current pad (source) from an other pad (sink).
+ *
+ * Returns: true if the pads were unlinked and false if the pads weren't linked.
+ */
+static VALUE
+rb_gst_pad_unlink(VALUE self, VALUE other_pad)
+{
+    GstPad *src_pad;
+    GstPad *sink_pad;
+
+    src_pad = SELF(self);
+    if (!CBOOL2RVAL(rb_obj_is_kind_of(other_pad, cGstPad))) {
+        rb_raise(rb_eTypeError, "Not a Gst::Pad");
+    }
+    sink_pad = RVAL2GST_PAD(other_pad);
+
+    return CBOOL2RVAL(gst_pad_unlink(src_pad, sink_pad));
+}
+
+/*
+ * Method: query(query)
+ * query: a query (see Gst::Query).
+ *
+ * Performs a query on the pad.
+ *
+ * Returns: the query result value, or nil if the query could not be performed.
+ */
+/*
+ * Method: query
+ */
+static VALUE
+rb_gst_pad_query(VALUE self, VALUE query)
+{
+    return CBOOL2RVAL(gst_pad_query(SELF(self), RVAL2GST_QUERY(query)));
+}
+
+/*
+ * Method: send_event(event)
+ * event: a Gst::Event.
+ *
+ * Sends an event to the pad, through a Gst::Event object. 
+ *
+ * Returns: true if the request event was successfully handled, false
+ * otherwise.
+ */
+static VALUE
+rb_gst_pad_send_event (VALUE self, VALUE event)
+{
+	return CBOOL2RVAL (gst_pad_send_event (RGST_PAD (self),
+					       RGST_EVENT (event)));
+}
+
+/*
+ * Method: caps
+ *
+ * Gets the capabilities of the pad element.
+ *
+ * Returns: a Gst::Caps object.
+ */
+static VALUE
+rb_gst_pad_get_caps(VALUE self)
+{
+    return GST_CAPS2RVAL_UNREF(gst_pad_get_caps(SELF(self)));
+}
+
+/*
+ * Method: negotiated_caps
+ *
+ * Gets the capabilities of the pad element.
+ *
+ * Returns: a Gst::Caps object.
+ */
+static VALUE
+rb_gst_pad_get_negotiated_caps(VALUE self)
+{
+    return GST_CAPS2RVAL_UNREF(gst_pad_get_negotiated_caps(SELF(self)));
+}
+
+/*
+ * Method: set_caps
+ *
+ * Sets the capabilities of the pad element.
+ *
+ * Returns: true if the setting succeeded
+ */
+static VALUE
+rb_gst_pad_set_caps(VALUE self, VALUE caps)
+{
+    return CBOOL2RVAL(gst_pad_set_caps(SELF(self), RVAL2GST_CAPS(caps)));
+}
+
+/*
+ * Method: set_active
+ *
+ * Sets the active state of the pad.
+ *
+ * Returns: true if the setting succeeded
+ */
+static VALUE
+rb_gst_pad_set_active(VALUE self, VALUE active)
+{
+    return CBOOL2RVAL(gst_pad_set_active(SELF(self), RVAL2CBOOL(active)));
+}
+
+/*
+ * Method: peer
+ *
+ * Get the peer of a pad
+ *
+ * Returns: Returns the peer pad or Qnil if there is none
+ */
+static VALUE
+rb_gst_pad_get_peer(VALUE self)
+{
+    return GST_PAD2RVAL_UNREF(gst_pad_get_peer(SELF(self)));
+}
+
+
+void
+Init_gst_pad (void)
+{
+    cGstPad = G_DEF_CLASS (GST_TYPE_PAD, "Pad", mGst);
+
+    rb_define_method(cGstPad, "direction", rb_gst_pad_get_direction, 0);
+    rb_define_method(cGstPad, "name", rb_gst_pad_get_name, 0);
+    rb_define_method(cGstPad, "pad_template", rb_gst_pad_get_pad_template, 0);
+    rb_define_method(cGstPad, "provides_query_types?", rb_gst_pad_provides_query_types, 0);
+    rb_define_method(cGstPad, "query_types", rb_gst_pad_get_query_types, 0);
+    rb_define_method(cGstPad, "each_query_type", rb_gst_pad_each_query_type, 0);
+    rb_define_method(cGstPad, "linked?", rb_gst_pad_is_linked, 0);
+    rb_define_method(cGstPad, "link", rb_gst_pad_link, 1);
+    rb_define_method(cGstPad, ">>", rb_gst_pad_link_shift, 1);
+    rb_define_method(cGstPad, "unlink", rb_gst_pad_unlink, 1);
+    rb_define_method(cGstPad, "query", rb_gst_pad_query, 1);
+    rb_define_method(cGstPad, "send_event", rb_gst_pad_send_event, 1);
+    rb_define_method(cGstPad, "caps", rb_gst_pad_get_caps, 0);
+    rb_define_method(cGstPad, "negotiated_caps", rb_gst_pad_get_negotiated_caps, 0);
+    rb_define_method(cGstPad, "set_caps", rb_gst_pad_set_caps, 1);
+    rb_define_method(cGstPad, "set_active", rb_gst_pad_set_active, 1);
+    rb_define_method(cGstPad, "peer", rb_gst_pad_get_peer, 0);
+
+    G_DEF_SETTERS(cGstPad);
+
+
+    G_DEF_CLASS(GST_TYPE_PAD_LINK_RETURN, "LinkReturn", cGstPad);
+    G_DEF_CONSTANTS(cGstPad, GST_TYPE_PAD_LINK_RETURN, "GST_PAD_");
+    G_DEF_CLASS(GST_TYPE_PAD_DIRECTION, "Direction", cGstPad);
+    G_DEF_CONSTANTS(cGstPad, GST_TYPE_PAD_DIRECTION, "GST_PAD_");
+    G_DEF_CLASS(GST_TYPE_PAD_FLAGS, "Flags", cGstPad);
+    G_DEF_CONSTANTS(cGstPad, GST_TYPE_PAD_FLAGS, "GST_PAD_");
+    G_DEF_CLASS(GST_TYPE_PAD_PRESENCE, "Presence", cGstPad);
+    G_DEF_CONSTANTS(cGstPad, GST_TYPE_PAD_PRESENCE, "GST_PAD_");
+}